Lets an AI client drive a Playwright browser with human-like mouse, typing, and scrolling, and record sessions as video or tests.
Also known as totigm/humanjs, @humanjs/mcp
- Stars
- 28
- Tools
- 38
- Downloads, 30 days
- 611
- Latest version
- —
- Last commit
- Nov 8, 2026
- License
- MIT
What is HumanJS MCP?
HumanJS lets an AI client drive a Playwright browser with human-like mouse, typing, and scrolling, and record sessions as video or tests. It exposes 38 tools, such as human_goto, human_click, human_rightClick.
Summary generated from the project's README
About HumanJS MCP server
Automating web browsers with natural movements is what HumanJS enables for AI agents and QA engineers. By integrating with Playwright, this server allows AI clients like Claude Desktop, Cursor, and Cline to perform web tasks using curved mouse paths, realistic typing rhythms, and natural scrolling. It transforms robotic automation into interactions that mimic human behavior, including reading pauses and varied interaction speeds.
Users can configure different interaction styles through personalities such as careful, fast, distracted, or precise. The server supports recording sessions to export them as video files, GIFs, or runnable Playwright test scripts. It is designed for developers building autonomous agents that need to navigate websites or testers who require human-paced execution to avoid issues with debounced inputs and animations. While it provides realistic motion, it does not include features like captcha solving or proxy rotation.
What you can do with it
- 1Driving AI agents through websitesAn AI agent can navigate a browser to book flights or fill forms using human-like mouse and keyboard movements.
- 2Creating realistic product demosDevelopers can record browser sessions to generate high-quality video or GIF walkthroughs that look natural.
- 3Improving QA test reliabilityEngineers can run automated tests at a human pace to ensure they do not break due to race conditions or animation states.
Written from the project's README. Every use case is checked against a quote from it.
How to install HumanJS MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall HumanJS MCP in Claude Code
$ claude mcp add humanjs -- npx -y @humanjs/mcpInstall HumanJS MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"humanjs": {
"command": "npx",
"args": [
"-y",
"@humanjs/mcp"
]
}
}
}Install HumanJS MCP in VS Code
.vscode/mcp.json
{
"servers": {
"humanjs": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@humanjs/mcp"
]
}
}
}Install HumanJS MCP in VS Code CLI
$ code --add-mcp '{"name":"humanjs","type":"stdio","command":"npx","args":["-y","@humanjs/mcp"]}'Install HumanJS MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"humanjs": {
"command": "npx",
"args": [
"-y",
"@humanjs/mcp"
]
}
}
}Install HumanJS MCP in Codex
$ codex mcp add humanjs -- npx -y @humanjs/mcpInstall HumanJS MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.humanjs] command = "npx" args = ["-y", "@humanjs/mcp"]
Install HumanJS MCP in Gemini CLI
$ gemini mcp add -s user humanjs npx -- -y @humanjs/mcpInstall HumanJS MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"humanjs": {
"command": "npx",
"args": [
"-y",
"@humanjs/mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for @humanjs/mcp 0.5.0 in an isolated container with no network and no keys. It answered and listed 38 tools.
HumanJS MCP tools 38
Read from the server with tools/listhuman_gotoNavigates the session's page to a URL. Plugins observe a "goto" action. Equivalent to a user typing a URL in the address bar.
human_clickMoves the cursor to the target along a humanized Bezier path and clicks. Target is a selector OR x/y coordinates — use coordinates for icon-only buttons or anything with no clean selector that you can see in a screenshot.
human_rightClickRight-clicks the target to open a context menu. Same motion as human_click; only the dispatched button differs. Target is a selector OR x/y coordinates.
human_doubleClickDouble-clicks the target — same humanized motion as human_click, but two presses within the OS double-click window. Use for things that open/activate on double-click (list rows, file items, editable cells). Target is a selector OR x/y coordinates.
human_hoverMoves the cursor to an element and settles on it (no click), letting hover-triggered UI fire — tooltips, dropdowns. Element-bound only; for positioning the cursor at coordinates without an element, use human_move.
human_moveMoves the cursor to a target along a Bezier path with no click and no settle dwell — pure positioning. Useful before a keyboard action, for canvas work, or cinematic beats. Target is a selector OR x/y coordinates.
human_dragDrags from one location to another — cursor → source, mousedown, source → destination, mouseup, all humanized. Each endpoint is a selector OR x/y coordinates (use coordinates for sliders, canvas, SVG handles).
human_typeClicks the element to focus it, then types with humanized per-key rhythm. The current personality controls speed, typo probability, and corrections (HUMANJS_PERSONALITY / human_set_personality). If this types into a search/filter, the results re-render (often debounced) — use a specific selector for the result, as the list shifts as it filters.
human_pasteInserts text in one shot (the Cmd-V semantic) — focuses the field, then sets the whole value via insertText with no per-key timing. Use for long strings where humanized typing would be slow. Does not fire the page paste event.
human_clearClears a text field (input/textarea/contenteditable) with a real keyboard gesture — click to focus, select-all, then delete — firing the input events the page expects. Use before human_type when you need to replace an existing value rather than append to it.
human_selectTextSelects (highlights) text inside an element — moves the cursor to it, then selects. By default selects all of the element’s text; pass `text` to select just that substring (found inside the element, whitespace-tolerant, first match; falls back to the whole element if not found). Use before copying, replacing, or triggering a highlight menu.
human_checkTicks a checkbox or radio — moves the cursor to it and clicks, but only if it is not already checked (a real user does not re-click a ticked box). Verifies the resulting state. Pass the checkbox/radio input itself (or a [role=checkbox]) — not a wrapping <label> — so the current state can be read and the click stays idempotent.
Show all 38 toolsShow fewer tools
human_uncheckUnticks a checkbox — humanized click only if currently checked. Radios cannot be unchecked by clicking (select a different option instead). Pass the checkbox input itself (or a [role=checkbox]) — not a wrapping <label> — so its state can be read and the click stays idempotent.
human_selectOptionChooses option(s) in a native <select> — moves the cursor to the dropdown, then sets the value (native selects open an OS menu automation can't drive, so the value is set programmatically, firing change/input). For custom DOM dropdowns, use human_click on the rendered options instead. Match by value(s); pass one string or an array for multi-selects.
human_uploadAttaches file(s) to a file input — moves the cursor to the control, then sets the files (never opens the OS dialog, which would hang). For safety, files are read by basename from HUMANJS_UPLOAD_DIR (default: the server working dir) — subdirectories, "../", and absolute paths are rejected, so the agent can't read and exfiltrate arbitrary local files. Pass the <input type="file"> selector and the filename(s).
human_pressPresses a single key (Enter, Tab, Escape, ArrowDown, …) or a chord (Mod+S, Cmd+Shift+P, Ctrl+C). "Mod" maps to Meta on Mac and Control elsewhere. Dispatches against focus — does not move the cursor; compose with human_click/human_move when you need both.
human_scrollScrolls the page or a container with a natural velocity profile. Default scrolls one viewport down. Use `target` for presets ("natural"/"end"/"top") or an element selector to scroll into view; `by` for a relative pixel delta; `to` for an absolute position.
human_readDwells as if reading the target — pause time derived from word count and the personality's reading speed, with a visible cursor scan across the text. Models the "user pauses to read" beat. Provide a selector OR literal text.
human_screenshotCaptures the current page (or a specific element if `selector` is given) as a PNG and returns it as image content the AI can view directly. Pass `filename` to also save it to disk (HUMANJS_OUTPUT_DIR); omit it for an ephemeral look-at-the-page capture.
human_page_textReturns the page's visible text (document.body.innerText). The fastest way to understand what's on screen without parsing HTML — prefer this over human_get_html unless you need element structure or attributes.
human_outlineReturns a compact accessibility-tree outline of the page (or a region) — every interactive element and landmark by its ARIA role + accessible name, as YAML (e.g. `- button "Sign in"`, `- textbox "Email"`). The most token-efficient way to see what is actionable and pick a selector: the names map directly to getByRole / accessible-name selectors. Prefer this over human_get_html for "what can I click or fill"; use human_screenshot when you need the visual layout.
human_get_textReturns the innerText of the first element matching `selector` — a specific label, price, status, or message. Set `all` to read every match instead, e.g. every row's title in a table; a sweep reports each match in document order, including ones that are not currently visible.
human_get_attributeReturns the value of an attribute on the first element matching `selector` (or reports it is absent). Handy for reading aria-label, data-*, href, value, disabled state, etc. — often how you confirm an icon-only button's purpose. Set `all` to collect the attribute across every match, which is the compact way to extract every image source or link target on a page.
human_get_htmlReturns the outerHTML of the first element matching `selector` — the element plus its children, including its own attributes (class, aria-label, etc.). The go-to tool for discovering the real selector of a control with no obvious text. Target a specific region; full-page HTML is large. Set `all` to dump every match, but prefer human_get_attribute with `all` when you only need one attribute from each — it returns the same information for a fraction of the tokens.
human_console_messagesReturns console output and uncaught page errors captured for this session, newest last. Capture starts when the session is created, so this covers everything since — including errors thrown during the first page load. The go-to tool when something looks wrong on the page but the screenshot doesn't explain why: CORS rejections, failed asset loads, and thrown exceptions all surface here and nowhere else.
human_network_requestsReturns network responses captured for this session, newest last, with method, URL, HTTP status and round-trip time. Requests that never got a response (DNS failure, blocked by CORS, aborted) are included with the browser's failure reason instead of a status. Use `onlyFailures` to answer "what broke?" in one call — it covers both 4xx/5xx responses and requests that never completed.
human_start_recordingBegins recording the session. Every humanized action until human_stop_recording is captured (frames + action timeline). The visible cursor is in the video. One recording per session at a time. For a natural-looking take: explore the flow first to find correct selectors, then dispatch the whole run — start_recording + every action + stop_recording — in a SINGLE turn (one batch of tool calls), so there are no model-thinking pauses between actions to leave dead air in the video.
human_stop_recordingStops the active recording and writes it to one or more files in HUMANJS_OUTPUT_DIR. Each filename's extension picks its format: .mp4/.webm = video, .gif = animated gif, .json = action timeline, .ts = runnable HumanJS script, .spec.ts/.test.ts = @playwright/test spec (humanized, with derived assertions). Pass several to export the same recording multiple ways, e.g. ["demo.mp4", "checkout.spec.ts"] for a video plus a ready-to-commit test. Path components are rejected for safety.
human_create_sessionOpens a new isolated session (its own browser context, cookies, viewport) under the given ID. Only needed for parallel browsers — for a single browser, just omit the session arg on other tools and the default session is used.
human_close_sessionCloses a session and frees its browser context. Closing the default session is allowed — it will be recreated lazily on the next call.
human_list_sessionsLists every currently-open session with its personality. Use to orient before acting on a specific session.
human_set_personalityChanges the humanization personality for a session at runtime. Pass a preset, or a blend of two presets (e.g. mostly careful with a touch of distracted). The browser, cookies, and scroll position are preserved — only the motion/typing/reading profile changes.
human_set_speedChanges a session's humanization pace at runtime. "human" = full realistic motion (best for recordings); "fast" = humanized but quicker; "instant" = no humanized motion (straight Playwright). Note: this changes how long each action takes to execute, not the wait between actions. Cannot change while recording.
human_set_viewportResizes a session's browser viewport at runtime. Use for a bigger/crisper recording or to test responsive layouts. The default size for new sessions is set by HUMANJS_VIEWPORT (default 1440×900).
human_emulate_mediaEmulates CSS media features for a session so you can verify the accessibility and theming paths a real user would get. `reducedMotion: 'reduce'` is the important one: it is the only way to check that a site's prefers-reduced-motion path actually works, and it is normally impossible to test without changing OS settings. Settings persist across navigations until changed; pass 'system' to stop emulating a feature.
human_browser_infoReports how the browser is obtained (ephemeral fresh profile, persistent profile, or attached over CDP), the channel, and whether logins persist. Use it to explain to the user why they are or are not signed in, and how to change it.
human_enable_persistenceSwitches HumanJS to a persistent browser profile so logins/cookies survive across runs. Takes effect on the next browser start; pass restartNow:true to apply immediately (restarting discards the current page — re-navigate after). For a permanent default, set HUMANJS_PERSIST=true in the MCP config instead. Note: this does NOT use your real Chrome profile (that stays an env-only, opt-in setting).
human_restart_browserCloses the browser and all sessions; the next action launches a fresh one in the current mode. Use to apply a persistence change, or to recover a wedged browser. Discards open pages/tabs — re-navigate afterward. (Does not affect a CDP-attached browser beyond disconnecting.)
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachabletotigm/humanjs is public and reachablegithub.com/totigm/humanjs ↗Pass
- Package names this repository as its source@humanjs/mcp names totigm/humanjs as sourcenpmjs.com/package/@humanjs/mcp ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for @humanjs/mcpnpmjs.com/package/@humanjs/mcp/v/0.5.0#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-08github.com/totigm/humanjs ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @humanjs/mcpPass
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubWhy
Modern websites are increasingly hostile to all browser automation, and they can't tell the difference between a scraper and an AI agent acting on a user's instructions. Cloudflare, DataDome, PerimeterX read your mouse trajectory and interaction rhythm — and they block on it.
If you're building:
- AI agents that book flights, fill forms, or monitor accounts on behalf of users
- QA tests where race conditions, debounced inputs, or animation states only break at real-user pace
- Demos and walkthroughs that need to look human-paced instead of robotic
- Onboarding recordings or supervised agent monitoring
…then your robotic Playwright runs are the problem.
HumanJS makes interactions feel natural. Curved mouse paths. Typing rhythm with hesitation. Reading dwell time based on word count. Configurable personalities. Drop-in for Playwright.
What HumanJS is not
A stealth tool. We do not ship:
- ❌ Captcha solvers
- ❌ Fingerprint masking
- ❌ Proxy rotation
- ❌ "Undetectable" promises
Sophisticated anti-bot systems will still detect us. We reduce friction for legitimate use cases — and we say no to the rest by design. If you need evasion tooling, you want a stealth plugin, not HumanJS.
Install
npm install @humanjs/playwright
# or
pnpm add @humanjs/playwright
Quick start
import { chromium, createHuman } from '@humanjs/playwright';
const browser = await chromium.launch();
const page = await browser.newPage();
const human = await createHuman(page, {
personality: 'careful', // careful | fast | distracted | precise
seed: 'session-42', // deterministic for tests
speed: 'human', // human | fast | instant
});
await human.goto('https://example.com');
await human.click('Sign in');
await human.type('Email', 'gonzalo@example.com');
await human.paste('Password', process.env.PW!);
await human.check('Remember me');
await human.read('Welcome back');
await human.scroll('natural');
Everything that's not specified humanizes by default. Selectors prefer accessible names and roles over CSS. Determinism via seed. CI-friendly via speed: 'instant'.
Personalities
await createHuman(page, { personality: 'careful' }); // slow, precise, few mistakes
await createHuman(page, { personality: 'fast' }); // quick but still natural
await createHuman(page, { personality: 'distracted' }); // scrolls back, retypes, hovers
await createHuman(page, { personality: 'precise' }); // minimal noise, smooth motion
Extend, override, or blend:
await createHuman(page, {
personality: { extends: 'careful', typing: { typoProbability: 0.1 } },
});
await createHuman(page, {
personality: blend('careful', 'distracted', 0.3),
});
Or build your own and publish it as @yourname/personality-*. The full Personality type is exported and stable.
AI agent integrations
Drive a humanized browser straight from your AI agent via the MCP server — works with Claude Code, Claude Desktop, Cursor, Codex, Cline, and any other MCP client. Register it in one command:
claude mcp add humanjs -- npx -y @humanjs/mcp
…or one-click for Cursor:
Every action the agent takes goes through HumanJS without changing your agent code. See @humanjs/mcp for the full tool catalog and per-client config.
Writing HumanJS by hand with an AI coding assistant? Install the skill so Claude Code, Cursor, and Codex know the API:
npx @humanjs/skill # this project
npx @humanjs/skill --global # every project (~/.claude/skills, ~/.codex/AGENTS.md)
Drops the HumanJS skill into your project (.claude/skills/, .cursor/rules/, or AGENTS.md) — or, with --global, into your home dir for every project. See @humanjs/skill. (The MCP server runs a humanized browser; the skill teaches an agent to write HumanJS.)
Recorder
const recording = await human.record(async () => {
await human.goto('/checkout');
await human.click('Buy now');
await human.type('Card number', '4242424242424242');
});
await recording.toVideo('checkout.mp4'); // mp4 / webm of the session
await recording.toGif('checkout.gif'); // palette-optimized gif for README embeds
await recording.toTimeline('checkout.json'); // structured JSON for analysis
await recording.toHumanJS('checkout.ts'); // runnable HumanJS script
await recording.toPlaywright('checkout.spec.ts'); // @playwright/test spec (humanized)
Replay a recorded timeline against a live page — driven through the same humanized
primitives, with per-step pass/fail and stop-at-first-failure (no @playwright/test needed):
import { replayTimeline } from '@humanjs/playwright';
const result = await replayTimeline(page, recording.timeline, {
onStep: ({ index, status }) => console.log(`${index}: ${status}`),
});
console.log(result.status); // 'pass' | 'fail'
Or replay a timeline while capturing frames and export the clean run as video/gif —
recordReplay is the timeline twin of human.record():
import { recordReplay } from '@humanjs/playwright';
const clip = await recordReplay(page, recording.timeline); // replays + captures, cursor visible
await clip.toGif('demo.gif');
await clip.toVideo('demo.mp4');
Or one-call for the simple case (browser/page lifecycle handled for you):
import { record } from '@humanjs/recorder';
await record({ output: 'demo.mp4' }, async (human) => {
await human.click('a');
await human.type('#search', 'humanjs');
});
Or skip writing the script entirely — record it visually:
npx @humanjs/generator https://your-app.com
@humanjs/generator opens a real Chromium window and a local (loopback-only) dashboard. As you click, type, scroll, and select text, each action is captured with a role-first selector (accessible name + role — the way a person sees the page, not a brittle CSS path) and streams into a live editor as a step. There you can:
- reorder (drag), relabel, and delete steps, and edit captured values
- pick a selector per step from the ranked candidates
- point-and-add assertions (
toBeVisible/toHaveText/toHaveURL) - mark a field as a secret so it exports as
process.env.X(passwords are always masked) - switch the personality (
careful/fast/distracted/precise)
Hit Run to replay the recording in a fresh window and watch each step go green or red — verify it passes before you export. When it looks right, export a @playwright/test spec (.spec.ts) or a standalone HumanJS script (.ts) — it runs through the same codegen the library ships, so generated tests stay in lockstep — or export an .mp4 / .gif of the clean replayed flow for a demo or tutorial.
In tests
Use the @humanjs/playwright/test fixture — it extends Playwright's test with a ready-to-use human, seeded from the test title and instant in CI, humanized locally. No boilerplate:
import { test, expect } from '@humanjs/playwright/test';
test('checkout flow', async ({ human, page }) => {
await human.goto('/');
await human.click('Buy now');
await expect(page).toHaveURL(/checkout/);
});
The seed (the test title) makes runs deterministic; speed: 'instant' in CI keeps the suite fast, full humanization runs locally. Customize per file or project: test.use({ humanOptions: { personality: 'distracted' } }).
Prefer to wire it yourself? Create the human explicitly:
import { test, expect } from '@playwright/test';
import { createHuman } from '@humanjs/playwright';
test('checkout flow', async ({ page }) => {
const human = await createHuman(page, {
seed: test.info().title,
speed: process.env.CI ? 'instant' : 'human',
});
await human.goto('/');
await human.click('Buy now');
await expect(page).toHaveURL(/checkout/);
});
Compared to alternatives
| HumanJS | Playwright | ghost-cursor | |
|---|---|---|---|
| Mouse trajectories | ✅ | ❌ | ✅ |
| Typing rhythm | ✅ | ❌ | ❌ |
| Reading dwell | ✅ | ❌ | ❌ |
| Scroll humanization | ✅ | ❌ | ✅ |
| Personalities | ✅ | ❌ | ❌ |
| Session recorder + code export | ✅ | partial | ❌ |
| AI agent integration (MCP server) | ✅ | ❌ | ❌ |
| Playwright-native | ✅ | ✅ | ❌ (Puppeteer) |
| Deterministic via seed | ✅ | n/a | ❌ |
ghost-cursor pioneered humanized mouse paths and is excellent at what it does. HumanJS is for the broader job: humanizing entire interaction sessions in Playwright, with first-class support for AI agents and QA suites.
Honest limits
- HumanJS will not defeat sophisticated bot detection (fingerprinting, TLS analysis, request patterns).
- HumanJS slows down test runs unless you use
speed: 'fast'orspeed: 'instant'. - HumanJS is Playwright-first. Puppeteer support is on the roadmap, not v1.
- HumanJS does not rotate proxies, spoof fingerprints, or solve captchas. We will not add these. Open an issue and we'll close it.
Roadmap
- Mouse + scroll + typing + reading primitives
- Personalities (careful, fast, distracted, precise) + blend / extend
- Session recorder → mp4 / GIF / JSON timeline
- MCP server (
@humanjs/mcp) for AI agents - Recorder code export (Playwright / HumanJS)
- AI coding-agent skill (
@humanjs/skill) - Visual generator (
@humanjs/generator) - Plugin system + community personality authoring (
@yourname/personality-*) - Recipes (
@humanjs/recipes) for common flows - Touch / mobile humanization
- Puppeteer adapter (
@humanjs/puppeteer)
See ROADMAP.md for what is in flight, what is blocked upstream, and what will never be built.
Contributing
We welcome PRs that:
- Improve interaction realism
- Add primitives for new behaviors (keyboard shortcuts, drag-and-drop, right-click menus, etc.)
- Publish personalities or recipes
- Build agent adapters
We do not accept PRs that:
- Implement captcha solvers, fingerprint masking, or proxy management
- Position HumanJS as a stealth tool
See CONTRIBUTING.md to get started, and please follow our Code of Conduct. To report a security issue, see the security policy.
Credits
The cubic Bezier path math behind humanized mouse trajectories is adapted from ghost-cursor by @Xetera (MIT-licensed). HumanJS humanizes a much broader surface — typing rhythm, reading dwell, scroll, the plugin system, personalities, AI-agent adapters — but the underlying coordinate generation builds on their solid foundation. See THIRD_PARTY_NOTICES.md for full attribution.
License
MIT — see LICENSE.
HumanJS MCP questions
How do I add HumanJS MCP to Claude Code?
Run claude mcp add humanjs -- npx -y @humanjs/mcp in your terminal. Add --scope user to make it available in every project.
How do I add HumanJS MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does HumanJS MCP provide?
It exposes 38 tools, including human_goto, human_click, human_rightClick, human_doubleClick, human_hover.
How do I add HumanJS to Claude Code?
Register the MCP server with a single command, or use the Cursor deeplink. It works with any MCP client, including Claude Desktop, Cursor, Codex, and Cline.
Can HumanJS record a browser session as a video or GIF?
Yes. Wrap your actions in human.record() and export the recording to mp4, GIF, a JSON timeline, a runnable HumanJS script, or a Playwright test spec.
Is HumanJS a stealth tool that bypasses bot detection?
No. It does not ship captcha solvers, fingerprint masking, or proxy rotation, and sophisticated anti-bot systems will still detect it.
Does HumanJS support different interaction personalities?
Yes, it offers careful, fast, distracted, and precise personalities, which you can extend or blend.
Can HumanJS runs be deterministic for tests?
Yes. Passing a seed makes runs deterministic, and speed: 'instant' keeps CI fast while full humanization runs locally.