Agentify Desktop: Driving Logged-In AI Web Sessions Over MCP

The subscription gap Agentify Desktop is built to close

Most MCP-capable coding agents reach models through API keys. That works until the developer already pays for ChatGPT Plus, Claude Pro or Gemini Advanced and does not want to fund a second meter. Agentify Desktop takes the opposite route: it keeps a real signed-in browser session open on your machine and exposes that session to MCP clients. The README lists Codex, Claude Code and OpenCode as the intended callers, and the supported sites are chatgpt.com, claude.ai, perplexity.ai, aistudio.google.com, gemini.google.com and grok.com. The audience is narrow and specific: a developer running an MCP-capable CLI locally who wants to route prompts into web UIs they are already authenticated against. It is not a hosted gateway, not a proxy for API traffic, and not a way to share sessions across a team.

Stable tab keys, hidden windows and the MCP tool surface

The mechanism is a local Electron app that opens browser tabs and a stdio MCP server that drives them. The README describes the core loop as keeping a real signed-in browser session open locally, calling it from an MCP client, and reusing a stable tab key across follow-up prompts. That key is the central abstraction. The server registers agentify_* tools, including agentify_query for sending a prompt to a tab, agentify_read_page for visible page text, agentify_navigate, agentify_ensure_ready for waiting on login, CAPTCHA or UI readiness, agentify_show and agentify_hide, agentify_status, tab management via agentify_tabs, agentify_tab_create and agentify_tab_close, artifact tools (agentify_save_artifacts, agentify_list_artifacts, agentify_open_artifacts_folder), bundle tools (agentify_save_bundle, agentify_list_bundles), and watch-folder tools (agentify_add_watch_folder, agentify_list_watch_folders, agentify_remove_watch_folder). Parallel tabs let different agents or tasks hold separate sessions. The README also notes that newly created browser tabs can be shown while debugging via the --show-tabs flag, which implies default behaviour is to keep them hidden. Two backends exist. chrome-cdp is the default and recommended, launching or attaching to a Chrome-family browser over Chrome DevTools Protocol. An electron backend with embedded windows is offered, but the README explicitly frames it as a fallback because SSO providers commonly block embedded Electron login. That is an honest admission: the embedded path is where the project started and where it still breaks against Google and similar identity providers.

Getting it running: npx, MCP registration and context packing

The preferred install avoids cloning the repo. Running npx @agentify/desktop starts the desktop GUI, and npx @agentify/desktop gui is the explicit form. A global install via npm install -g @agentify/desktop exposes the agentify-desktop binary. The MCP server runs over stdio with npx @agentify/desktop mcp, and npx @agentify/desktop mcp --show-tabs shows newly created tabs during debugging. Registration is one command per client. For Codex: codex mcp add agentify-desktop -- npx -y @agentify/desktop mcp. For Claude Code: claude mcp add --transport stdio agentify-desktop -- npx -y @agentify/desktop mcp. OpenCode takes a JSON block with type local, command ["npx", "-y", "@agentify/desktop", "mcp"] and enabled true. Two environment variables tune the Chrome CDP backend: AGENTIFY_DESKTOP_CHROME_DEBUG_PORT (the README shows 9333) and AGENTIFY_DESKTOP_CHROME_BIN, which points at the Chrome binary. Context packing is controlled per call through contextPaths plus maxContextChars, maxContextFiles and maxContextInlineFiles, with the README's example using 120000, 80 and 30 respectively. The tool result returns a packedContextSummary so you can see what was included, attached or skipped. That summary matters more than it looks: without it, a truncated context is invisible to the calling agent.

Artifacts and bundles: the part that actually saves work

The artifact workflow is the most concrete feature in the README. A prompt sent through agentify_query with key ui-concepts can ask the web UI to generate three UI concept images. A follow-up agentify_save_artifacts call with mode images and maxImages 3 writes them to local disk and returns file paths. Those absolute paths can then be passed back as attachments in a later agentify_query, letting the model iterate on its own output. Bundles serve a similar purpose for text: agentify_save_bundle and agentify_list_bundles let a conversation or packed context be stored and reused. Watch folders extend this to local directories. The practical gain is that generated images and long conversations stop being ephemeral. The practical cost is that every artifact lives wherever the app decides to put it, and the README does not document a configurable storage root, so disk growth is something you manage by watching the artifacts folder rather than by setting a quota.

Where the browser-session approach breaks down

This is browser automation pointed at UIs that were never designed to be automated, and the failure modes follow from that. Vendor UI changes can break selectors without warning. CAPTCHA and bot checks are anticipated enough that agentify_ensure_ready exists specifically to wait for them, which tells you they happen. Rate limits and account flags are a live risk when a scripted loop hits a consumer chat interface. The chrome-cdp default exists because SSO blocks embedded Electron login, so on machines where Chrome is not installed at a path the app can find, or where the profile is not signed in, the whole chain stalls. Headless or server environments are a poor fit: the model requires a real signed-in browser, and the README's first-run steps include signing in to the target vendor in a browser window. Anything unattended, reproducible or audited is the wrong use case. If you need deterministic output in CI, an API key and a normal SDK call is the correct tool, not this.

How it differs from Playwright and Puppeteer

Playwright and Puppeteer also drive Chrome, so the comparison is not about capability but about contract. Those libraries expect you to write selectors, wait conditions and assertions against a page you control or can inspect. Agentify Desktop inverts that: you do not write selectors at all. You call agentify_query with a tab key and a prompt, and the app handles the interaction with the vendor UI on your behalf. The trade is obvious. You gain a stable interface across six sites and lose visibility into what happens between the prompt and the response. When a vendor redesigns its composer, a Playwright script fails loudly at a known selector; Agentify Desktop fails somewhere inside agentify_query, and the README does not describe the internal selector strategy or a repair path for users. That is the real difference in approach, and it is also the reason the project must ship releases often. Three releases landed on 2026-05-18 alone, which is consistent with chasing third-party UI drift.

Licence, maintenance and what to check before relying on it

Agentify Desktop is MPL-2.0. That is a file-level copyleft licence, so modifications to MPL-covered files must stay under MPL when redistributed, while larger works that merely combine with the code can be licensed differently. This is a summary, not legal advice; read the licence text and your own obligations before shipping anything derived from it. Maintenance cost sits with the upstream project, since the value depends on keeping six vendor UIs working, and the release cadence suggests that work is ongoing. Your own cost is setup and re-authentication: sessions expire, vendors log you out, and the chrome-cdp backend depends on a Chrome install you keep signed in. Before depending on it, confirm that Codex or Claude Code can list the agentify_* tools after registration, that agentify_ensure_ready reports ready on each target site, and that a second agentify_query on the same key actually sees the first turn. If that last check fails, the tab key abstraction is not holding and the workflow collapses.

Editorial conclusion

Adopt Agentify Desktop if you already pay for ChatGPT, Claude or Gemini and want Codex or Claude Code to reach those sessions through MCP without a second API bill. Skip it if you need unattended CI runs or programmatic determinism. Before trusting it, verify that your Chrome profile signs in to each vendor under the chrome-cdp backend, that agentify_ensure_ready clears any CAPTCHA, and that a follow-up agentify_query on the same tab key returns the prior context.

Official sources

1. agentify-sh/desktop on GitHub
2. License: MPL-2.0
3. Project website
4. README
5. Releases