Agentify Desktop: an MCP bridge to your signed-in ChatGPT, Claude and Gemini sessions

The gap Agentify Desktop fills: subscriptions you already pay for

Most MCP servers wrap an API. Agentify Desktop wraps a browser session. The README states the goal plainly: it lets MCP-capable tools such as Codex, Claude Code and OpenCode "use the AI subscriptions you are already signed into, while keeping browser state, files, and automation on your machine." That is the whole pitch, and it addresses a real friction point. A developer with a ChatGPT Plus or Claude Pro subscription and a Codex or Claude Code install has two separate worlds: the CLI agent with repository access but no access to those web models, and the browser with model access but no repository access. Agentify Desktop is the bridge between them. It is aimed at individual engineers and small teams who want a coding agent to consult a web model inside an existing workflow, not at platform teams building a service. The supported sites are listed explicitly: chatgpt.com, claude.ai, perplexity.ai, aistudio.google.com, gemini.google.com and grok.com. Note what is absent: no API-key path, no headless server deployment, no multi-user story. This is a desktop tool for one operator on one machine.

How the tab-key model and MCP tool surface actually work

The architecture is a local Electron application that manages browser tabs, plus a separate MCP server process that speaks stdio to your CLI. The README describes the core loop in three steps: keep a real signed-in browser session open locally, call it from an MCP client, and reuse a stable tab key across follow-up prompts. That stable key is the central abstraction. Instead of addressing a tab by index or URL, you name it, and the same name refers to the same conversation on later calls. Parallelism follows from the same idea: separate keys give separate sessions, so one agent can hold a ChatGPT thread while another holds a Grok thread. The MCP server registers agentify_* tools. agentify_query sends a prompt to a keyed tab and returns the assistant response. agentify_read_page reads visible page text. agentify_navigate moves a tab to a URL. agentify_ensure_ready waits for login, CAPTCHA or UI readiness, which is the honest acknowledgement that these pages are not always immediately usable. agentify_show and agentify_hide bring windows forward or minimize them, which matters because the browser is real and visible by default. Tab lifecycle is handled by agentify_tabs, agentify_tab_create and agentify_tab_close, and state inspection by agentify_status. Two subsystems sit on top: an artifact store for files and images generated in a tab, and a context packer that folds local files into prompts. The repository layout matches this description, with separate modules for the tab manager, the artifact store, the bundle store, the context packer, the orchestrator and the browser backends.

Installing Agentify Desktop and running a first real query

The README's preferred path avoids cloning the repository entirely. Node.js 20 or newer is required, and an MCP-capable CLI (Codex, Claude Code or OpenCode) if you want tool integration. Start the desktop GUI with npx:

npx @agentify/desktop

A Control Center window opens. Create or show a ChatGPT tab there, then sign in to the vendor in the browser window that appears. The README's first-run sequence puts login before MCP registration, which is the right order: the MCP server has nothing to drive until a session exists. If you prefer a global install, the alternative is:

npm install -g @agentify/desktop
agentify-desktop

Now register the MCP server with your CLI. For Codex, the README gives:

codex mcp add agentify-desktop -- npx -y @agentify/desktop mcp

For Claude Code, the transport is stated explicitly:

claude mcp add --transport stdio agentify-desktop -- npx -y @agentify/desktop mcp

OpenCode uses a config file instead, with a local command array:

{
  "mcp": {
    "agentify-desktop": {
      "type": "local",
      "command": ["npx", "-y", "@agentify/desktop", "mcp"],
      "enabled": true
    }
  }
}

Then ask the client to use a key. The README's example prompt is:

Use Agentify Desktop with tab key repo-triage.
Ask ChatGPT to summarize this repo in 8 bullets and list the top 3 risky areas to change first.
Return the answer and keep the tab key stable for follow-ups.

What you should see is a response attributed to the web model, returned through the MCP client, with the tab still alive under the key repo-triage for a follow-up call. While debugging, the README offers a flag that shows newly created browser tabs:

codex mcp add agentify-desktop -- npx -y @agentify/desktop mcp --show-tabs

The global-install equivalent of the MCP entry point is agentify-desktop-mcp, with the same --show-tabs option.

Chrome CDP is the default backend because SSO blocks embedded browsers

This is the most interesting design decision in the project, and the README is unusually direct about why it exists. Agentify Desktop supports two browser backends. chrome-cdp launches or attaches to a Chrome-family browser over the Chrome DevTools Protocol, and the README calls it the default and recommended backend. electron uses embedded windows managed by Agentify Desktop, and the README says to use it "only as an explicit fallback." The stated reason is that SSO providers commonly block embedded Electron login. Anyone who has tried to sign into Google inside an embedded webview has met that wall. The consequence is architectural: the default mode is not a self-contained app but an orchestrator that attaches to a browser you already have. Two environment variables adjust it. AGENTIFY_DESKTOP_CHROME_DEBUG_PORT sets the debug port, shown in the README with the value 9333. AGENTIFY_DESKTOP_CHROME_BIN points at a specific Chrome binary, with a macOS example path. The presence of a file named TODO_fix-sso-popup-hardening.md in the repository root suggests the popup and SSO handling is still an area of active work rather than a settled problem. Treat the CDP default as a dependency: it works because Chrome is there, and it inherits Chrome's profile, extensions and login state.

Where Agentify Desktop breaks, and when it is the wrong tool

The failure mode is structural, not incidental. Agentify Desktop drives vendor web interfaces, and web interfaces change. The repository ships a selectors.json file, which means the project encodes knowledge of each vendor's DOM. When ChatGPT or Claude ships a redesign, that file is what has to be updated, and until it is, queries against the affected vendor can fail. The README does not document a rollback path or a compatibility guarantee for selector breakage, and the CHANGELOG is the only place to look for whether a given release tracked a UI change. A second limitation follows from the first: agentify_ensure_ready exists precisely because readiness is not guaranteed. The README lists login, CAPTCHA and UI readiness as conditions to wait for, which is an admission that a query can be blocked by a human-verification step that no MCP client can satisfy on its own. Third, this is a desktop application bound to one machine and one signed-in profile. There is no documented server mode, no multi-tenant isolation and no queue. If you need unattended automation that runs for weeks, or an auditable record of every model call, a vendor API is the correct instrument and Agentify Desktop is the wrong one. It is also the wrong tool if your organisation prohibits driving consumer web sessions programmatically, regardless of what the software can technically do.

Agentify Desktop versus calling the vendor APIs directly

The real alternative is not another MCP server. It is the official API from each vendor: OpenAI's API for ChatGPT-class models, Anthropic's for Claude, Google's for Gemini, and so on. The difference in approach is fundamental. An API call is a documented, versioned request with a stable response schema, rate limits you can read and a bill you can forecast. Agentify Desktop is a browser automation layer whose contract is a rendered web page. In exchange it offers three things an API does not. It uses a subscription you already hold rather than metered API credit. It reaches capabilities exposed only in the web product, which is what makes the image-generation artifact workflow possible at all. And it keeps the session, including any files or context you attached in the browser, on your machine. The context packer is a smaller differentiator: the README shows contextPaths with maxContextChars, maxContextFiles and maxContextInlineFiles, and the tool result includes a packedContextSummary so you can see what was included, attached or skipped. That is a legitimate convenience, but you can reproduce it with a script and an API key in an afternoon. The honest framing is that Agentify Desktop trades reliability and auditability for subscription reuse and web-only features.

Maintenance cost, licence and what the MPL-2.0 means here

The last push to the repository was on 2026-05-18, which is the same day as the v0.2.4 release, and the repository is not archived. Three releases landed within roughly two hours on that date (v0.2.2, v0.2.3, v0.2.4), which reads as a burst of fixes rather than a steady cadence. The practical maintenance question is not whether the maintainers are active but whether you are willing to track vendor UI changes yourself. Because selectors.json ships in the published package, a determined user can patch a broken selector without waiting for a release, and that is the realistic escape hatch. The upgrade path is npm: npx @agentify/desktop always fetches the published version, and the global install updates with npm install -g @agentify/desktop. Pinning a version is possible but works against you here, since the newest release is the one most likely to match the current vendor DOM. On licensing, the package is MPL-2.0, a file-level copyleft licence: modifications to MPL-covered files must be made available under the same licence, while larger works that combine it with other code can be licensed differently. The repository also ships a TRADEMARKS.md file, so the project name and marks are governed separately from the code. This is a description of the licence text, not legal advice; if you plan to redistribute a modified build, have counsel read the MPL-2.0 text and the trademark file together.

Editorial conclusion

Adopt it if you already hold web subscriptions for ChatGPT, Claude, Gemini, AI Studio, Perplexity or Grok and want Codex, Claude Code or OpenCode to reach them without API keys, accepting that the transport is a browser UI held together by selectors.json. Do not adopt it where an audit trail, deterministic output or unattended long-running automation is required. Before committing, verify that agentify_status returns a ready tab after login on your target vendor, and read selectors.json to see how much of that vendor's DOM the project currently encodes.

Frequently asked questions

Official sources

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