Headful versus headless browsers for AI agents.

Headless Chrome runs without visible platform windows. Headful Chrome displays those windows. That visible difference remains operationally important. The underlying browser story has changed.

Chrome unified its headless and headful implementations. Since Chrome 112, headless creates undisplayed platform windows. Chrome states other browser functions remain available. Old compatibility assumptions deserve retesting.

Puppeteer still launches headless by default. Playwright does the same for normal execution. Both frameworks can switch into headed operation. Their debugging tools make that switch useful.

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.

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.

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.

Legba describes a ready skill for agents. It provides routing and isolated browser sessions. Sessions run on Legba's infrastructure. Each task receives separate session scope.

The public description does not promise mode selection. It does not specify Playwright compatibility. It does not specify Puppeteer compatibility. This page adds none of those claims.

Evaluate the skill by required agent jobs. List observations, actions, and intervention needs. Confirm every required interface directly. Test consequential workflows before production use.

The focused value remains browser separation. Agent machines need not host the session. Routing is available on demand. Infrastructure ownership stays with Legba.