◉ANTIGRAVITY LABJP
Articles/Integrations
⬡ Integrations/2026-11-21Intermediate

Moving Your Antigravity Setup from Zed to VS Code, JetBrains, or Xcode: The Three Places You Can't Just Copy

When you move an agy acp registration from Zed to VS Code, a JetBrains IDE, or Xcode, three things change: the config key, the command path, and authentication plus available models. Here is the diff from the official docs and a small script that converts your Zed settings.

ACPAntigravity CLI45ZedXcode4JetBrainsVS Code5Migration10

I was working on the iOS build of my wallpaper app in Xcode, and I wanted the same Antigravity agent to be reachable from Zed and from a JetBrains IDE too. So one afternoon I put every editor's setup steps side by side on a single page.

Antigravity CLI ships an ACP (Agent Client Protocol) server, agy acp. Your editor launches it as a subprocess and talks to it over JSON-RPC on stdin and stdout. The official docs put it simply: every client except Android Studio registers the same command, agy, with the single argument acp.

Even so, pasting the few lines from Zed's settings.json into another editor doesn't always work. I assumed at first that the same command meant I could just copy it. What I found, once everything was laid out, is that the command stays the same — it's everything around it that changes.

Only three things change

Reading the official guide (Other editors (ACP)) editor by editor, the differences come down to three:

  1. Where the config lives and what key it uses (agent_servers or acp.agents, a file or a settings screen)
  2. The command path (whether plain agy works or you need an absolute path)
  3. Authentication and the models you can pick (where the API key goes, whether third-party models show up)

The agent itself, its tools, your permission rules, and your sign-in all come from Antigravity CLI, so those don't move at all. Keeping that split in mind makes the migration much smaller than it first looks.

1. The config key and where it lives

This is the most visible difference. "Register Antigravity" means four different shapes in four places.

EditorLocationKeyDifference from Zed
Zedsettings.json (zed: open settings file)agent_serversThe baseline. Includes "type": "custom"
VS CodeUser settings.jsonacp.agentsNo native support; needs the community ACP Client extension. No type
JetBrains IDEs~/.jetbrains/acp.jsonagent_serversSame key name, but no type, and the command is an absolute path
XcodeSettings > Intelligence > Add an Agent(form fields)Not a file — you fill in Command and Arguments

Because JetBrains uses the same agent_servers key as Zed, it's tempting to paste the whole block. But "type": "custom" is Zed's format and doesn't appear in the JetBrains example. The shared key name is exactly why it's worth keeping the two apart.

Android Studio is the exception: it installs Antigravity from the ACP Registry, with its own setup flow.

2. The command path

"command": "agy" may work in Zed and still fail in JetBrains or Xcode. The docs say:

  • JetBrains IDEs don't always inherit your shell's PATH. Use the absolute path from which agy.
  • Xcode doesn't expand ~ or read your shell's PATH. Put an absolute path in the Command field.

A CLI installed with Homebrew can be visible from Terminal and invisible to an app launched from the Dock — a familiar macOS story. If agy acp --help works in Terminal but the editor can't start the agent, this is the first thing I'd check.

One more note on Xcode's Arguments field. The official steps only show the single word acp; they don't say how to enter extra flags like --sandbox there. If your Zed setup uses something like ["acp", "--sandbox"], it's worth confirming after the move that the sandbox is actually on.

3. Authentication and available models

agy acp reuses the credentials cached by an interactive agy sign-in. Without them, requests fail with Authentication required (code -32000). On SSH hosts or machines without a browser, the docs suggest running agy acp --login in a terminal first (I wrote about the SSH case in Antigravity sign-in never comes back in Zed over SSH).

The thing to watch is a GEMINI_API_KEY placed under env in your Zed config. The docs themselves warn that editor settings files are plain text and often synced or shared. Having done it once in Zed is no reason to copy the same line forward. Let the CLI hold the credentials; let the editor config hold only the command. A migration is a good moment to redraw that line.

The other difference is the model list. Gemini models are available in every client, but third-party models are only offered to JetBrains IDEs (including JetBrains Air), Android Studio, Android Performance Analyzer, Zed, and Xcode. The VS Code ACP Client extension isn't on that list. If you used a third-party model in Zed and move to VS Code, expect a shorter list. It isn't a bug, so there's no need to reinstall anything.

Converting your Zed settings

Fixing those three spots by hand every time gets old, so I put together a small script that reads Zed's settings.json and prints the VS Code, JetBrains, and Xcode versions. Zed settings can contain comments and trailing commas, which plain json.loads rejects, so that part gets a small pre-pass.

#!/usr/bin/env python3
"""Read the Antigravity entry from Zed agent_servers and print configs for other editors."""
import json, re, shutil, sys
from pathlib import Path
 
def load_jsonc(path: Path) -> dict:
    text = path.read_text(encoding="utf-8")
    out, i, in_str = [], 0, False
    while i < len(text):
        c = text[i]
        if in_str:
            out.append(c)
            if c == "\\" and i + 1 < len(text):
                out.append(text[i + 1]); i += 2; continue
            if c == '"':
                in_str = False
        elif c == '"':
            in_str = True; out.append(c)
        elif text.startswith("//", i):
            while i < len(text) and text[i] != "\n":
                i += 1
            continue
        elif text.startswith("/*", i):
            end = text.find("*/", i + 2)
            i = len(text) if end == -1 else end + 2
            continue
        else:
            out.append(c)
        i += 1
    cleaned = re.sub(r",(\s*[}\]])", r"\1", "".join(out))  # drop trailing commas
    return json.loads(cleaned)
 
def main() -> int:
    src = Path(sys.argv[1]).expanduser() if len(sys.argv) > 1 else Path("~/.config/zed/settings.json").expanduser()
    servers = load_jsonc(src).get("agent_servers", {})
    entry = servers.get("Antigravity")
    if not entry:
        print(f"No Antigravity entry found in: {src}"); return 1
 
    command = entry.get("command", "agy")
    args = entry.get("args", ["acp"])
    env = entry.get("env", {})
    abs_cmd = command if command.startswith("/") else shutil.which(command)
 
    warnings = []
    if not abs_cmd:
        warnings.append(f"{command} is not on PATH. JetBrains and Xcode need an absolute path")
        abs_cmd = "/absolute/path/to/agy"
    if "GEMINI_API_KEY" in env:
        warnings.append("GEMINI_API_KEY is set in env. It was not copied into the new configs")
    if "--dangerously-skip-permissions" in args:
        warnings.append("--dangerously-skip-permissions is set. Decide again whether the new editor needs it")
 
    vscode = {"acp.agents": {"Antigravity": {"command": command, "args": args}}}
    jetbrains = {"agent_servers": {"Antigravity": {"command": abs_cmd, "args": args}}}
 
    print("# Add to VS Code settings.json (ACP Client extension)")
    print(json.dumps(vscode, ensure_ascii=False, indent=2))
    print("\n# JetBrains ~/.jetbrains/acp.json")
    print(json.dumps(jetbrains, ensure_ascii=False, indent=2))
    print("\n# Xcode > Settings > Intelligence > Add an Agent")
    print(f"Command  : {abs_cmd}")
    print(f"Arguments: {' '.join(args)}")
    for w in warnings:
        print(f"\n⚠️ {w}")
    return 0
 
if __name__ == "__main__":
    sys.exit(main())

Running it against a sample config with comments and trailing commas (--sandbox in args, GEMINI_API_KEY in env) ended with these two lines:

⚠️ agy is not on PATH. JetBrains and Xcode need an absolute path
⚠️ GEMINI_API_KEY is set in env. It was not copied into the new configs

The script deliberately skips two things: it never copies the API key, and it never carries "type": "custom" into other editors. The first follows the line I drew above; the second is because a shared key name doesn't mean a shared format. On a machine where agy isn't on PATH, the absolute-path field stays as a placeholder — fill it in with the output of which agy.

Three checks after the move

Once the config is in place, these three checks per editor catch most gaps early:

  1. Does it start? Open a new thread, pick Antigravity, and send one short question. If it doesn't start, confirm agy acp --help works in Terminal, then switch the command to an absolute path.
  2. Do permission prompts appear? If you see Allow / Deny cards when the agent edits a file or runs a command, your permission rules are coming through from the CLI. This is also where you decide again whether the new editor really needs --dangerously-skip-permissions (the docs limit it to sandboxed or disposable environments).
  3. Is there a log? When something's off, the clues are in ~/.gemini/antigravity-cli/log/acp-*.log. To keep logs separate per editor, add --log-file with a path to args.

If your editor configures HTTP MCP servers, note that agy acp needs --process-per-session for those — an easy one to miss. For narrowing down missing MCP tools, see Antigravity MCP won't connect? Work through config, startup, auth, network in that order.

More editors, still one agent

As an indie developer switching between editors, I've learned that settings scattered across tools eventually leave you unsure which one is right. What I like about ACP is that the agent lives in one place — Antigravity CLI — and each editor is just a window onto it.

What differs from window to window is only those three things: where the config lives, the command path, and authentication plus models. A good first step is to run your current Zed settings.json through the script above and clear the ⚠️ lines one at a time.

Share

Thank You for Reading

Antigravity Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

  • ✦Copy-paste ready implementation code
  • ✦New advanced guides published daily
  • ✦$5/mo or $10 for lifetime access
View Membership →

If you found this article helpful, a small tip ($1.50) would mean a lot to us. Your support helps keep this site ad-free and covers server and hosting costs.

Related Articles

⟐ Editor View2026-11-17
Antigravity Sign-In Never Comes Back in Zed over SSH — Log In on the Remote Machine First
When Antigravity (agy acp) stalls at 'Launching browser login flow...' in a remote Zed session, here is how to tell auth from startup failures, cache credentials with agy acp --login, find the logs, and what to try next.
⬡ Integrations2026-11-06
Moving Conductor From a Gemini CLI Extension to an Antigravity CLI Plugin: Leave spec.md and plan.md Alone, Compare Before and After
Conductor is now a plugin instead of a Gemini CLI extension, and it runs in Antigravity CLI too. Your spec.md and plan.md files don't need to move; here is a small script and a short routine to prove nothing changed when you install it.
⬡ Integrations2026-10-22
The Project-Local mcp_config.json Is Read, but No MCP Server Starts — Checking With a One-File Probe
Antigravity CLI logs that it is using a project-local config, yet the MCP servers in it never start. Where the official issue stands (still open as of November 2026), what that log line does and does not promise, a tiny probe server to check your own setup, a table for telling similar symptoms apart, and realistic ways to keep MCP servers per project.