Agentify Desktop

Agentify Desktop is a local-first control center for AI work: connect your real, logged-in AI subscriptions to your MCP-compatible CLI tools, all on your own machine.

Why teams keep it open

• 🌐 Real browser sessions, real accounts: automate the web UIs you already use, without API-key migration.
• 🔌 MCP-native integration: works with Codex, Claude Code, OpenCode, and other MCP-capable clients.
• 🧵 Parallel tabs for parallel work: run multiple isolated workflows at once using stable tab keys.
• 📎 Practical I/O support: upload files, save generated images/files locally, and reattach them in later prompts.

Supported sites

Supported

• chatgpt.com
• perplexity.ai
• claude.ai
• aistudio.google.com
• gemini.google.com
• grok.com

Planned

• Additional vendor profiles via vendors.json + selector overrides.

CAPTCHA policy (human-in-the-loop)

Agentify Desktop does not attempt to bypass CAPTCHAs or use third-party solvers. If a human verification appears, the app pauses automation, brings the relevant window to the front, and waits for you to complete the check manually.

Requirements

• Node.js 20+ (22 recommended)
• MCP-capable CLI (optional, for MCP): Codex, Claude Code, or OpenCode

Quickstart (macOS/Linux)

Quickstart installs dependencies, auto-registers the MCP server for installed clients (Codex/Claude Code/OpenCode), and starts Agentify Desktop:

git clone git@github.com:agentify-sh/desktop.git
cd desktop
./scripts/quickstart.sh

Debug-friendly: show newly-created tab windows by default:

./scripts/quickstart.sh --show-tabs

Foreground mode (logs to your terminal, Ctrl+C to stop):

./scripts/quickstart.sh --foreground

Choose MCP registration target explicitly:

./scripts/quickstart.sh --client auto     # default
./scripts/quickstart.sh --client codex
./scripts/quickstart.sh --client claude
./scripts/quickstart.sh --client opencode
./scripts/quickstart.sh --client all
./scripts/quickstart.sh --client none

Manual install & run

npm i
npm run start

The Agentify Control Center opens. Use it to:

• Show/hide tabs (each tab is a separate window)
• Create tabs for ChatGPT, Perplexity, Claude, Google AI Studio, Gemini, and Grok
• Tune automation safety limits (governor)

Sign in to your target vendor in the tab window.

If your account uses SSO (Google/Microsoft/Apple), keep Settings → Allow auth popups enabled in the Control Center. ChatGPT login often opens provider auth in a popup, and blocking popups can prevent login from completing.

Browser backend choice

Agentify Desktop now supports two browser backends:

• electron (default): embedded windows managed directly by Agentify.
• chrome-cdp: launches/attaches a real Chrome-family browser via the Chrome DevTools Protocol.

If Google/Microsoft/Apple SSO is fighting Electron, switch to Settings → Browser backend → Chrome CDP, save, then restart Agentify Desktop.

chrome-cdp notes:

• Uses a managed browser profile at ~/.agentify-desktop/chrome-user-data/
• Default remote debugging port is 9222
• Prefers your local Chrome install, but also works with Chromium / Brave / Edge
• Uses real browser login flows, which is the main reason to choose it

Profile options in the Control Center:

• Agentify isolated profile (default): safest and most predictable
• Existing Chrome profile: reuses your normal Chrome session/profile

If you choose Existing Chrome profile, fully quit regular Chrome first, then start Agentify Desktop. If Chrome is already using that profile, Agentify will fail fast with a hint instead of attaching to the wrong browser state.

First Useful Workflow

This is the simplest real workflow to prove the product is doing something useful.

1. Start Agentify Desktop:

npm i
npm run start

2. In the Control Center:

• set Browser backend to Chrome CDP
• keep Chrome profile mode as Agentify isolated profile
• click Save
• restart Agentify Desktop if you changed the backend

3. Click Show default, then sign in to ChatGPT in the browser window.

4. Register the MCP server in your CLI.

Codex:

codex mcp add agentify-desktop -- node /ABS/PATH/TO/desktop/mcp-server.mjs

Claude Code:

claude mcp add --transport stdio agentify-desktop -- node /ABS/PATH/TO/desktop/mcp-server.mjs

5. In your MCP client, run this exact workflow:

Prompt:

Create or reuse an Agentify tab with key repo-triage.
Use ChatGPT to answer this:
"Summarize the architecture of this repo in 8 bullets, then list the top 3 risky areas to change first."
Return the answer and keep the tab key stable for follow-ups.

6. Follow up in the same tab:

Prompt:

Use the existing Agentify tab key repo-triage.
Ask for a test plan for changing one of those risky areas.
Return the plan as a short checklist.

That proves the core loop:

• keep a persistent logged-in web session
• call it from Codex / Claude Code over MCP
• reuse the same tab/session across multiple requests

First artifact workflow

This is the fastest way to prove the image/file pipeline is useful.

1. Generate something in a stable tab:

Prompt:

Use tab key sprite-lab.
Generate a simple 2D pixel-art robot sprite on a transparent background.
Give me 3 variations.

2. Save the latest generated outputs to disk:

{
  "tool": "agentify_save_artifacts",
  "arguments": {
    "key": "sprite-lab",
    "mode": "images",
    "maxImages": 3
  }
}

The response includes local file paths. You can immediately reuse one of them in the next step.

3. Reattach one of the returned paths in the next prompt:

{
  "tool": "agentify_query",
  "arguments": {
    "key": "sprite-lab",
    "prompt": "Take the attached sprite and create a damaged version with one broken eye and darker metal.",
    "attachments": [
      "/ABS/PATH/FROM/PREVIOUS/STEP/sprite.png"
    ]
  }
}

4. If you want the folder in Finder/Explorer:

{
  "tool": "agentify_open_artifacts_folder",
  "arguments": {
    "key": "sprite-lab"
  }
}

That proves the artifact loop:

• generate in a real web session
• save locally without manual browser downloads
• reuse the saved file path in the next MCP prompt

First codebase stuffing workflow

Use this when you want to hand a repo or folder tree to the model without manually copy/pasting files.

1. Ask Agentify to pack a folder into the next query:

{
  "tool": "agentify_query",
  "arguments": {
    "key": "repo-review",
    "prompt": "Summarize this codebase in 8 bullets and list the top 3 risky files to change first.",
    "contextPaths": [
      "/ABS/PATH/TO/YOUR/REPO"
    ]
  }
}

2. Inspect the returned packedContextSummary in the tool result.

It tells you, at a glance:

• which roots were scanned
• how many files were scanned
• which text files were inlined
• which files were auto-attached
• which files were skipped and why

3. If the first pass is too large or too small, tighten the budget explicitly:

{
  "tool": "agentify_query",
  "arguments": {
    "key": "repo-review",
    "prompt": "Focus only on the rendering pipeline and state management.",
    "contextPaths": [
      "/ABS/PATH/TO/YOUR/REPO"
    ],
    "maxContextChars": 60000,
    "maxContextFiles": 40,
    "maxContextChunkChars": 4000,
    "maxContextChunksPerFile": 2,
    "maxContextInlineFiles": 12,
    "maxContextAttachments": 6
  }
}

4. Reuse the same tab key for follow-ups:

{
  "tool": "agentify_query",
  "arguments": {
    "key": "repo-review",
    "prompt": "Now give me a safe refactor plan for the top risky file."
  }
}

That proves the codebase loop:

• point Agentify at a folder
• let it inline text files and auto-attach binaries/images
• inspect what it included vs skipped
• keep the same live session for follow-up questions

Watch-folder ingestion workflow

Use this when you want a dead-simple local drop zone.

1. Open the default inbox folder:

{
  "tool": "agentify_open_watch_folder",
  "arguments": {}
}

2. Drop files into that folder from Finder/Explorer or another local tool.

3. Agentify will index them automatically. If you want to force it immediately:

{
  "tool": "agentify_scan_watch_folder",
  "arguments": {}
}

4. List the ingested files and reuse their paths:

{
  "tool": "agentify_list_artifacts",
  "arguments": {
    "limit": 20
  }
}

Then pass one of the returned path values into the next attachments array.

You can also add your own watched folders:

{
  "tool": "agentify_add_watch_folder",
  "arguments": {
    "name": "sprites",
    "folderPath": "/ABS/PATH/TO/sprites"
  }
}

List them:

{
  "tool": "agentify_list_watch_folders",
  "arguments": {}
}

Remove one later:

{
  "tool": "agentify_remove_watch_folder",
  "arguments": {
    "name": "sprites"
  }
}

Reusable context bundle workflow

Use this when you keep sending the same codebase roots, screenshots, and instruction prefix.

1. Save a bundle once:

{
  "tool": "agentify_save_bundle",
  "arguments": {
    "name": "repo-review",
    "promptPrefix": "You are reviewing this repository for safe incremental changes. Be concrete and concise.",
    "contextPaths": [
      "/ABS/PATH/TO/repo/src",
      "/ABS/PATH/TO/repo/package.json"
    ],
    "attachments": [
      "/ABS/PATH/TO/repo/docs/architecture.png"
    ]
  }
}

2. Reuse it later in a normal query:

{
  "tool": "agentify_query",
  "arguments": {
    "key": "repo-review-chatgpt",
    "bundleName": "repo-review",
    "prompt": "Find the riskiest auth-related change points and propose the smallest safe refactor plan."
  }
}

3. If needed, add extra one-off context on top of the bundle:

{
  "tool": "agentify_query",
  "arguments": {
    "key": "repo-review-chatgpt",
    "bundleName": "repo-review",
    "promptPrefix"