Headful versus headless browsers for AI agents.

Headless Chrome runs without visible platform windows. Headful Chrome displays those windows. Headed is another name for headful. The visible difference still matters operationally.

Chrome unified its headless and headful implementations. Since Chrome 112, headless creates undisplayed platform windows. Old headless now ships as chrome-headless-shell. That split began with Chrome 132. Old compatibility assumptions deserve retesting.

Puppeteer still launches headless by default. Playwright does the same for normal execution. Playwright's default headless Chromium uses a separate shell. Its `chromium` channel opts into newer headless mode. Both frameworks can run headed for live inspection.

For agents, mode is only one dimension. Perception arrives through DOM, accessibility, screenshots, or video. Actions arrive through automation interfaces. Human oversight uses separate controls.

Framework defaults favor headless execution. Playwright and Puppeteer both launch headless unless told otherwise. Chrome itself runs headless only with the --headless flag.

Cloud defaults vary by vendor. Kernel ships browsers headful by default. Steel runs new cloud sessions headful by default. Browserbase docs describe its browsers as headless.

Live viewing depends on the platform, not the label. Browserbase pairs its headless browsers with live view. Kernel offers live view and replays only in headful mode.

Check the exact default before comparing results.

The best mode follows the operating model. Production agents need evidence and control. Developers need fast diagnosis. Reviewers need understandable intervention paths.

No row declares a universal winner. Both modes can capture screenshots. Both can expose page structure. Both can fail differently across environments. Controlled tests settle specific questions.

Mode can change the bill on hosted browsers. Kernel publishes separate per-second rates by mode. Its headful rate is eight times its headless rate. GPU-accelerated headful costs six times more again.

Memory follows the same pattern. Kernel headless browsers default to 1 GB of memory. Headful browsers default to 8 GB. Idle browsers in standby accrue no usage cost.

Measure cost per completed task in your chosen mode.

A visible browser does not automatically provide vision. The agent still needs observations. Those observations may be structural or visual. Each representation loses different information.

DOM and accessibility data expose semantic structure. Screenshots expose layout and rendered pixels. Network events expose requests. Console logs expose application messages.

Headless browsers can capture screenshots. Playwright and Puppeteer both document screenshot APIs. Therefore visual agents do not inherently require headful mode. They require reliable visual observations.

Headful mode helps nearby humans observe live behavior. That can speed development. It can also support manual intervention. Production still needs recorded evidence afterward.

Agents fail for many ordinary reasons. Selectors can become ambiguous. Navigation can race page state. Authentication can expire. Dialogs can block progress.

Playwright's debug mode launches headed browsers. Its inspector can step through actions. Developers can inspect locators and logs. This shortens the feedback loop.

Headful development does not require headful production. Reproduce the failure visibly first. Then retain a trace or screenshot. Finally retest the production mode.

Some failures disappear during slow observation. Timing changes can hide races. Keep normal-speed replay in the loop. Compare artifacts across both executions.

Unattended agents need bounded authority. Browser mode does not supply that boundary. Tools, credentials, destinations, and approvals determine reachable actions. Logs show what happened later.

Headless mode fits unattended infrastructure naturally. Chrome requires no visible interface there. Playwright's normal mode follows this pattern. Puppeteer also defaults to headless.

Headful production can still make sense. Remote operators may need live viewing. Some workflows require direct intervention. The surrounding platform must expose that control safely.

Either mode needs lifecycle management. Create scoped sessions. Limit accessible credentials. Close resources after work. Preserve only required evidence.

First, headless does not mean text-only. Modern Chrome still renders pages. Frameworks can capture visual output. Agents can receive those pixels.

Second, headful does not mean human-like. Automation interfaces still control the browser. Websites may observe many environmental signals. A visible window proves nothing alone.

Third, headless does not guarantee efficiency. Resource use depends upon workload and configuration. Measure representative sessions. Include rendering, media, traces, and concurrency.

Fourth, headful does not guarantee compatibility. Browser version and launch settings still matter. Extensions and policies can alter behavior. Exact workflows require controlled tests.

A mode label answers one question. Production integration needs several contracts.

Require a named connection protocol. Require explicit lifecycle and timeout behavior. Ask how operators observe the running browser.

Screenshots do not require a visible window. Playwright and Puppeteer expose them directly. Live intervention remains a separate capability.

Do not infer a headful API from screenshots. Do not infer observability from a mode flag. Verify each interface independently.

Do not benchmark a toy page. Select a representative workflow. Include authentication and navigation. Include the hardest interactive step. Include the required evidence path.

Run both modes with matching versions. Keep network conditions comparable. Record success and intervention rates. Record resource use and completion time.

Review failures by root cause. Separate page changes from mode differences. Separate agent planning failures from browser failures. Separate infrastructure failures from workflow policy.

Then choose the simplest operating model. Keep a documented debugging path. Keep a separate fallback path. Recheck after major browser upgrades.

Takeover needs a live view that accepts input. Playwright's headed debug mode covers local work. Remote platforms stream the page instead. Steel's interactive view accepts remote mouse and keyboard input.

Treat live-view links as credentials. Steel's debug URLs work without authentication. Add your own access controls before sharing one.

Legba's published skill documents a human handoff. The session API's handoff call returns a view link. The hosted MCP server names this step request_human. Agent writes are refused while the person holds control. Reads keep working, so the agent can watch.

A resume call returns control to the agent. The view link carries its own token. It ends with the session. The skill documents no headed or headless setting. Remote CDP attachment remains undocumented.