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:
- Where the config lives and what key it uses (
agent_serversoracp.agents, a file or a settings screen) - The command path (whether plain
agyworks or you need an absolute path) - 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.
| Editor | Location | Key | Difference from Zed |
|---|---|---|---|
| Zed | settings.json (zed: open settings file) | agent_servers | The baseline. Includes "type": "custom" |
| VS Code | User settings.json | acp.agents | No native support; needs the community ACP Client extension. No type |
| JetBrains IDEs | ~/.jetbrains/acp.json | agent_servers | Same key name, but no type, and the command is an absolute path |
| Xcode | Settings > 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 fromwhich agy. - Xcode doesn't expand
~or read your shell'sPATH. 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:
- Does it start? Open a new thread, pick Antigravity, and send one short question. If it doesn't start, confirm
agy acp --helpworks in Terminal, then switch the command to an absolute path. - 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). - 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-filewith a path toargs.
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.