agy-mcp
Summary: This MCP server lets an MCP client delegate tasks to a local Google Antigravity CLI (agy) over stdio.
Start a new Antigravity conversation with
antigravity_runfor repository research, planning, second opinions, or explicitly requested edits; returns output and aconversation_idfor follow-up.Continue an existing conversation with
antigravity_continuebyconversation_id; omitting it resumes the most recent conversation but requires exclusive server access.Configure calls with prompt, workspace, model, effort, mode (
plan/accept-edits), autonomy (safe/sandbox/fullif server opt-in), and timeout.List available model slugs/display names with
antigravity_models; it may contact Antigravity but does not start a model turn.Calls can modify workspace files and are open-world/destructive, so use trusted workspaces, verify changes, and treat model output as untrusted.
README also documents opt-in
antigravity_batchDAG orchestration andantigravity_fetchartifact retrieval, but these tools are not present in the supplied schema.
Integrates with Google Antigravity CLI to start and continue Antigravity conversations, list models, and run tasks using configurable workspace, mode, autonomy, and timeout settings.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@agy-mcp Start an Antigravity conversation to review auth flow in /home/user/project and list edge cases."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
agy-orch-mcp
日本語 · 設計ドキュメント (Japanese Design Doc) · Apache-2.0
agy-orch-mcp is a local Model Context Protocol server that lets an MCP client delegate work to the Google Antigravity CLI (agy). It communicates over stdio, starts agy as a child process, and returns CLI output as structured MCP content.
It is designed for personal local workflows and open-source adaptation. It is not an official Antigravity product and does not replace Antigravity's access controls or account requirements.
Overview & The agy-first Model
For detailed architecture, design rationale, and operational planning, see docs/design.ja.md (in Japanese).
agy-orch-mcp enables an agy-first division of labor:
External Frontier Host: Codex CLI/IDE or Claude Code acts as the orchestrator. The host focuses on task decomposition, structured prompt packet formulation, and final review of diffs and evidence. It avoids performing repository investigation, web search, or code editing directly.
Antigravity Execution Engine: The local Antigravity CLI (
agy) serves as the execution engine, handling repository research, web searches, code modification, testing, and self-correction loops.No Recursive Delegation: An Antigravity CLI session executing a delegated task must complete its work directly using native tools. It must not recursively call
agy-orch-mcpor delegate work back to the host.Delegation Guidance vs. Host Capabilities: The server supplies MCP initialization instructions and tool descriptions that guide the client host to delegate execution tasks to Antigravity. These instructions express default workflow guidance; they do not and cannot forcibly disable or replace the host's other built-in tools.
Related MCP server: antigravity-mcp
What it provides
MCP tool | Availability | Purpose |
| Default | Starts a new Antigravity conversation and returns its result and, when supplied by the CLI, its |
| Default | Continues a conversation by its required |
| Default | Runs |
| Opt-in | Executes a multi-task DAG with validation gates in isolated Git worktrees, producing an artifact-only |
| Opt-in | Retrieves safe slices of artifacts (stdout, stderr, patches, digest, manifest, request, plan, events) by logical selector. |
run and continue accept a prompt, an absolute workspace, an optional model and effort, a mode (plan or accept-edits), an autonomy level, a per-turn timeout (timeout_seconds, 10–900, default 900), an optional slot queue timeout (queue_timeout_seconds, 0–900, default 0), and a return_mode (raw, digest, or structured). Opt-in tools (antigravity_batch and antigravity_fetch) require AGY_MCP_ENABLE_BATCH=true and AGY_MCP_ENABLE_FETCH=true (or setting AGY_MCP_TOOL_SURFACE=batch).
Model Selection & Precedence
Model selection resolves in the following order:
The explicit
modelargument provided in the MCP tool call (antigravity_runorantigravity_continue).The server environment variable
AGY_MCP_DEFAULT_MODEL(if set and non-empty).The server built-in default model (
gemini-4-neon-high).
Subagents and worker tiers resolve as follows:
AGY_MCP_SUBAGENT_MODELdefaults togemini-4-argon-medium. When the--install-guardhook is installed,agysessions spawned byagy-orch-mcpreceiveSessionStartguidance andPreToolUseenforcement (swarmaction: "add"defaults toAGY_MCP_SUBAGENT_MODEL, andinvoke_subagentModel: "inherit"/ omitted is rewritten to the matching subagent tier).In
antigravity_batch,fasttier workers default toAGY_MCP_FAST_MODEL(falling back toAGY_MCP_SUBAGENT_MODEL, defaultgemini-4-argon-medium) andreasoningtier workers (including escalated repairs) default toAGY_MCP_REASONING_MODEL(defaultgemini-4-carbon-high). Escalation is skipped when the reasoning tier would resolve to the same model as the fast tier.
Query available model slugs using antigravity_models, then cache or specify the desired slug.
Safety, Workspace Boundaries, and Bridge Status Classification
The default request settings are mode: "plan" and autonomy: "safe".
safeinherits workspace trust and permissions configured inagy. It is not a read-only guarantee.Output returned by the worker is untrusted; hosts should verify execution using the machine-extracted
verified_outputsledger andgit diffrather than commands quoted in the model's prose response.mode(planoraccept-edits) signals intended agent behavior. In headless mode, the currentagyCLI issues a diagnostic indicating that--modehas no effect when--disable-slash-commandsis active. Consequently,modeis an intent signal and not an operating system security boundary.autonomygoverns permission handling:safe(default): Inherits workspace trust and permissions configured inagy, plus the bridge's fixed deny rules and command guard.sandbox: Adds the CLI's terminal sandbox restrictions.full: Passes--dangerously-skip-permissionsto the CLI. Rejected unlessAGY_MCP_ALLOW_FULL_AUTONOMY=trueis set in the server environment.
AGY_MCP_ALLOWED_ROOT, when set, permits only canonical workspaces beneath that root. This restricts workspace selection only; it does not sandbox a child process's filesystem or network access.Command Guard (
--install-guard), Subagent Model Hook & Fixed Deny Rules:Running
agy-orch-mcp --install-guardadds one environment-gated lifecycle hook namedagy-orch-mcp-guard(SessionStart+PreToolUseforrun_command,swarm, andinvoke_subagent) to~/.gemini/config/hooks.json(preserving any other hooks and writing a timestamped.bakbackup);agy-orch-mcp --uninstall-guardremoves it.The hook evaluates
run_commandtool calls only when the bridge setsAGY_ORCH_MCP_GUARD=1, and injects/enforcesAGY_MCP_SUBAGENT_MODEL(AGY_ORCH_MCP_SUBAGENT_MODEL) onSessionStart,swarm, andinvoke_subagentonly for bridge-spawned sessions, so interactive or non-bridgeagysessions are unaffected. Measuredagybehavior: a hook returning"ask"auto-approves in headless mode (so the guard never returns"ask"), whereas an empty hook response abstains.When active, the guard returns
"deny"for remote-changinggit/ghoperations (git push, mutatinggh pr/issue/repo/release/workflow/run/secret/variable/labelsubcommands, andgh apiwithout an explicitGETmethod, including viash -c,xargs,env, ortimeout/nohup/nicewrappers) and for unquoted redirection or command substitution (>,<,$(, backticks) with an actionable reason the worker can act on. For everything else, it returns"deny_unless_prior_grant"(with targeted rewrite hints for path-qualified binaries, Go templates{{, unquoted parentheses, and env prefixes) so a command missing frompermissions.allowreports a tool error to the worker instead of aborting the headless turn.In
safeandsandboxmodes, the bridge also always passes fixed deny rules (command(git push)and mutatingcommand(gh ...)) via--settings, whichagymerges with the user's allow list.agy-orch-mcp --doctorreports the guard hook status (installed,missing, oroutdated) and audits~/.gemini/antigravity-cli/settings.jsonfor permission risks (high,medium,low). Disable guarding on the server withAGY_MCP_GUARD=off.
Per-Conversation Environment Isolation (
AGY_MCP_ENV_ISOLATION):Controlled by
AGY_MCP_ENV_ISOLATION=full(default) |install|offunderAGY_MCP_ENV_ROOT(default<XDG_STATE_HOME or ~/.local/state>/agy-orch/env). Each conversation gets its own directory (<AGY_MCP_ENV_ROOT>/<conversation_id>), which is reused onantigravity_continueand pruned after 24 hours of inactivity at server startup.install(andfull) setsGOBIN,npm_config_prefix,BUN_INSTALL,PNPM_HOME,CARGO_INSTALL_ROOT,PYTHONUSERBASE,CHOKIDAR_USEPOLLING=1, andWATCHPACK_POLLING=true(so file watchers use polling), and prepends the isolatedbindirectories toPATH.fulladditionally isolates caches and state:GOPATH,GOMODCACHE,GOCACHE,npm_config_cache,npm_config_store_dir,BUN_INSTALL_CACHE_DIR,CARGO_HOME,PIP_CACHE_DIR, andUV_CACHE_DIR.Trade-offs:
fullmode re-downloads Go modules, npm packages, or Rust crates per conversation, and isolatingCARGO_HOMEskips~/.cargo/config.toml. SetAGY_MCP_ENV_ISOLATION=installwhen shared caches or user Cargo configuration are required.
Evidence, Preflight Warnings & Bridge Status Classification:
Machine-Extracted Command Ledger (
verified_outputs): The bridge extracts everyrun_commandstep from theagyJSON stream intoverified_outputs(step_index,command,statuscompleted|failed|denied|background|running,exit_code,output_tail,error,full_output_path,background_task_id,duration_seconds). Hosts should trustverified_outputsover commands quoted inresponse.Structured Handoff (
return_mode: "structured"): Passes--json-schema(src/handoff-schema.ts:summary,changes,verification,facts,side_effects,blockers) and returns the parsed object inhandoff(orhandoff_erroron invalid JSON) alongsideresponse.Preflight Warnings (
preflight_warnings): Before starting a non-fullturn, the bridge checks command candidates in the prompt againstpermissions.allow,permissions.deny, and fixed deny rules, returningpreflight_warningsfor commands that headlessagywould deny, plus a warning when the guard hook is not installed.PERMISSION_DENIED&denied_commands: Whenagyrecordsdenied_actions, the bridge classifies the result asstatus: "PERMISSION_DENIED", merges denied commands from the stream and conversation transcript intodenied_commands(including denials that only appear as the last tool call in the transcript), and attachespartial_responseandworkspace_changes.Context Rotation (
context): Every run/continue result carriescontext(turns and cumulativetotal_tokens). PastAGY_MCP_CONTEXT_ROTATE_TOKENS,context.rotate_recommendedistrueand the host should start a newantigravity_runwith a compact handoff.EMPTY_RESPONSE: WhenagyreportsSUCCESSwith an empty response string, the bridge classifies the result asstatus: "EMPTY_RESPONSE"withpartial_responseandworkspace_changesso the caller can inspect side effects before retrying.
Structured Task Packets
When delegating tasks to antigravity_run, provide a concise task packet scoped to a <= 15-minute resumable turn. Because the guard hook returns actionable hints on shell constructs, prompts no longer need long lists of forbidden shell characters—just keep the "one simple command per call" rule:
{
"prompt": "GOAL: Implement JWT authentication middleware.\nSCOPE: Edit only src/auth.ts and test/auth.test.ts. Do not touch config files.\nCONSTRAINTS: Follow TypeScript strict conventions. Run one simple command per call (`pnpm test`).\nHANDOFF: Summarize changes, external URLs/facts, and any blockers.",
"workspace": "/absolute/path/to/workspace",
"mode": "accept-edits",
"autonomy": "safe",
"timeout_seconds": 900,
"return_mode": "structured"
}Batch Orchestration (antigravity_batch & antigravity_fetch)
When opted in via AGY_MCP_ENABLE_BATCH=true and AGY_MCP_ENABLE_FETCH=true (or AGY_MCP_TOOL_SURFACE=batch), the server provides advanced multi-task DAG batch orchestration:
Isolated Worktrees & Artifact-Only Delivery: Each task worker runs in an isolated Git worktree branched from the base revision. Validated patches are integrated in deterministic topological order and saved as an artifact (
final.patch). The host working tree is never directly modified.Clean Workspace Requirement:
workspace.dirty_policyis"reject"and requires a clean working repository (commit or stash uncommitted changes before invoking batch).Ownership vs. Reference Scope:
task.ownsspecifies the exact file paths/globs the worker has permission to edit (owns ⊆ scope.includeandowns ∩ scope.exclude = ∅).scope.includedefines broader read/reference visibility.Gate Command Execution:
gate.commandrequires an explicit argv array (string[]), never raw shell strings, preventing shell injection or unmonitored subshell expansion.Containment Model: Worktree isolation, static path validation, and argv execution provide defense-in-depth application boundaries; they do not constitute an operating-system-level sandbox.
Bounded Retries, Deadlines & Clamping: Batches enforce execution limits (up to 50 worker calls, 16 parallel tasks, 7,200,000ms / 2h wall time). Requested budget values exceeding server limits are automatically clamped and reported in
budget_adjustmentsrather than rejected. Bounded execution loops are tracked bybudget.max_worker_calls,max_repair_attempts,max_replans, andwall_time_ms. Per-turn worker timeouts are capped at900,000ms (15 minutes); when a worker turn hits the cap, the scheduler automatically resumes it in the same worktree and conversation with a bridge-written resume prompt, counted againstmax_worker_calls. Effort-suffixed model slugs (such asgemini-4-carbon-highorgemini-4-argon-medium) are resolved without passing a conflicting--effort lowflag. Periodic progress notifications (heartbeat) are emitted when aprogressTokenis supplied.Token Budget, Preflight Capacity & Dynamic Digest: Output is summarized within
return.max_tokens(default 1400) using deterministic progressive shedding accounting for the entire MCP envelope. Upfront preflight validation rejects impossible budgets before worker or worktree creation, preservingCAPACITY_EXCEEDEDand recovery pointers. (Phase 6 semantic compression is optional and not implemented; real-world 20+20 host rollout benchmarks were not run).Safe Artifact Fetching & Raw Capture Fidelity:
antigravity_fetchretrieves full or sliced outputs using logical selectors (task:<id>:stdout,task:<id>:stderr,task:<id>:patch,gate:<id>:stdout,gate:<id>:stderr,manifest,digest,request,plan,events) or artifact IDs with cursor pagination (byte_offset). Physical CLI stream-json stdout and stderr are faithfully preserved in batch task artifacts for post-run recovery, while internal raw stdout is strictly omitted from legacy MCP tool outputs. Raw filesystem paths are rejected.Minimal Tool Surface (
AGY_MCP_TOOL_SURFACE=batch): Suppresses legacyantigravity_run,antigravity_continue, andantigravity_modelstools, publishing onlyantigravity_batchandantigravity_fetchto conserve host context tokens.Client Configuration Examples: For batch profiles, consult examples/codex-batch.toml and examples/claude-code-batch.mcp.json.
Parallel Calls, Timeouts, and Bounded Recovery
The server runs up to eight agy commands concurrently by default (AGY_MCP_MAX_CONCURRENT).
All commands, including
antigravity_models, count toward the concurrency limit. When all slots are in use, calls returnBUSYimmediately by default (queue_timeout_seconds: 0), or wait in a FIFO queue for up toqueue_timeout_seconds(0–900) while emitting queue position progress notifications (Queued for an agy slot (position N)) and reportingqueue_wait_secondsin the result.Independent tasks with different explicit
conversation_idvalues or new runs can execute in parallel.Concurrent requests using the same explicit conversation ID serialize: a simultaneous request for the same conversation ID immediately returns
BUSY.Conversation locks and limits apply within one server process. Workspace files, credentials, and CLI state remain shared.
All MCP tools (
antigravity_run,antigravity_continue,antigravity_models,antigravity_batch, andantigravity_fetch) advertiseannotations.readOnlyHint: trueandannotations.destructiveHint: falseso MCP host schedulers can dispatch multiple tool calls in a single turn concurrently:Claude Code maps
annotations.readOnlyHint: truedirectly to its internalisConcurrencySafe()check, executing simultaneousantigravity_runor distinct-IDantigravity_continuecalls in a single assistant message in parallel (relay subagents are unnecessary; rebuilddistwithpnpm buildafter upgrading so the running server advertises the annotation). Claude Code also moves MCP calls that run longer than 2 minutes to the background automatically (CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS).OpenAI Codex CLI / IDE dispatches multiple MCP tool calls in a single turn concurrently when
[mcp_servers.<name>]setssupports_parallel_tool_calls = true.For parallel code modifications across the same repository, prefer
antigravity_batch, which parallelizes inside a single call and isolates each task in its own Git worktree.
MCP Tasks Extension (
io.modelcontextprotocol/tasks, revision2026-07-28): Enabled by default (AGY_MCP_TASKS=auto; setAGY_MCP_TASKS=offto disable). A client that negotiates revision2026-07-28and advertisesio.modelcontextprotocol/tasksreceives a task handle (resultType: "task") and pollstasks/get(or cancels viatasks/cancel). Verified with SDK clients in tests; Claude Code documents support from v2.1.304 for main-conversation calls.15-Minute Turn Cap (
timeout_seconds):timeout_secondsdefaults to900and accepts integers from10through900(15 minutes).agyends the turn itself via--print-timeout <N>sand the bridge hard-kills the process tree 60 seconds later. Capping turns at 15 minutes enforces fast feedback cycles and splits long tasks into resumable turns. A cut-off turn returnsstatus: "TIMEOUT"withresumable: true,conversation_id,partial_response,verified_outputs,workspace_changes,terminated_tasks, andturn_seconds; continue the task withantigravity_continue. Note thatduration_secondsfromagyis cumulative per conversation, whereasturn_secondsmeasures this turn.Shortened Responses (
response_outline&resource_link): Returned tool responses are capped byAGY_MCP_MAX_OUTPUT_CHARS(default40000;16000recommended for host context efficiency). When a response is shortened, the full text is saved toresponse_artifact.path, accompanied byresponse_outline(Markdown heading levels andstart_line–end_lineranges) and aresource_linkcontent item (file://URI toresponse.txt) so the host can read only the sections it needs.Handling
BUSY: Usequeue_timeout_seconds(up to900) or wait/serialize calls rather than triggering rapid retry storms.Handling
TIMEOUTandEMPTY_RESPONSE: OnTIMEOUTwithresumable: true, inspectpartial_response,verified_outputs,workspace_changes, andterminated_tasksand continue withantigravity_continue. OnEMPTY_RESPONSE, inspectworkspace_changes(git status) before retrying.Handling
PERMISSION_DENIEDand Errors: Reviewdenied_commandsandworkspace_changes, then either continue with a named permitted alternative or report the concrete blocker to the user rather than silently shifting execution back to the host.
Requirements
Node.js 22 or newer
pnpm 10 or newer (the repository pins pnpm 10.34.9)
An installed, authenticated Antigravity CLI available as
agy, or an executable path supplied throughAGY_MCP_BINA workspace that Antigravity is allowed to use
Official documentation references:
Install from Source
git clone https://github.com/Kaikei-e/agy-orch-mcp.git
cd agy-orch-mcp
pnpm install --frozen-lockfile
pnpm build
node dist/index.js --install-guard
pnpm run doctornode dist/index.js --install-guard (or agy-orch-mcp --install-guard) installs the env-gated PreToolUse command guard hook in ~/.gemini/config/hooks.json (use --uninstall-guard to remove it). pnpm run doctor checks the configured workspace, verifies required agy CLI flags, reports the guard hook status, and runs a permissions audit on ~/.gemini/antigravity-cli/settings.json without initiating a model turn.
For an optional live smoke test after authenticating agy:
pnpm run probeThe probe invokes run and then continue on the returned conversation. It consumes live Antigravity quota and creates conversations; it is deliberately excluded from CI.
Connect an MCP Client
Build the server, then configure your client to launch the compiled entry point.
Restart the client session: Always restart your Codex CLI/IDE or Claude Code session after modifying MCP configuration files. When editing existing configuration files, merge server tables carefully to preserve existing settings.
Claude Code (.mcp.json)
For Claude Code, add a stdio server entry to .mcp.json in your project root:
{
"mcpServers": {
"antigravity": {
"command": "node",
"args": ["/absolute/path/to/agy-orch-mcp/dist/index.js"],
"env": {
"AGY_MCP_DEFAULT_WORKSPACE": "/absolute/path/to/workspace",
"AGY_MCP_ALLOWED_ROOT": "/absolute/path/to",
"AGY_MCP_MAX_CONCURRENT": "8",
"AGY_MCP_MAX_OUTPUT_CHARS": "16000"
}
}
}
}Tip: Setting AGY_MCP_MAX_OUTPUT_CHARS="16000" keeps returned tool output compact, preserving the host model's context window.
OpenAI Codex CLI / IDE (config.toml)
For Codex CLI or Codex IDE, add the stdio server to ~/.codex/config.toml (global) or .codex/config.toml (trusted projects):
[mcp_servers.antigravity]
command = "/absolute/path/to/node"
args = ["/absolute/path/to/agy-orch-mcp/dist/index.js"]
startup_timeout_sec = 20
tool_timeout_sec = 3660
supports_parallel_tool_calls = true
[mcp_servers.antigravity.env]
AGY_MCP_DEFAULT_WORKSPACE = "/absolute/path/to/workspace"
AGY_MCP_ALLOWED_ROOT = "/absolute/path/to"
AGY_MCP_MAX_CONCURRENT = "8"
# Recommended compact output limit to protect host context:
# AGY_MCP_MAX_OUTPUT_CHARS = "16000"
# Optional default model slug discovered via `antigravity_models`:
# AGY_MCP_DEFAULT_MODEL = "a-slug-returned-by-antigravity_models"
# Remove this entry when `agy` is available in Codex's PATH:
AGY_MCP_BIN = "/absolute/path/to/agy"Codex CLI registration can also be performed via:
codex mcp add antigravity \
--env "AGY_MCP_DEFAULT_WORKSPACE=/absolute/path/to/workspace" \
--env "AGY_MCP_ALLOWED_ROOT=/absolute/path/to" \
--env "AGY_MCP_MAX_CONCURRENT=8" \
--env "AGY_MCP_MAX_OUTPUT_CHARS=16000" \
-- "/absolute/path/to/node" "/absolute/path/to/agy-orch-mcp/dist/index.js"Remember to add startup_timeout_sec = 20 and tool_timeout_sec = 3660 to the resulting entry in config.toml.
Personal Client Settings & Git Hygiene
Do not commit machine-specific MCP configuration files to Git. Ensure your repository .gitignore includes:
# Personal MCP client settings
.mcp.json
.codex/
.claude/settings.local.jsonVerify exclusions using:
git check-ignore -v .mcp.json .codex/config.toml .claude/settings.local.json
git status --shortReusable Project Templates
To establish agy-first policies in downstream projects, copy the provided templates:
examples/AGENTS.md: Project-agnostic agy-first delegation rules.
examples/CLAUDE.md: Claude Code configuration importing
@AGENTS.md.
When introducing these templates to an existing project, merge the rules into the existing AGENTS.md or CLAUDE.md rather than overwriting project-specific instructions, build commands, or domain guidelines.
Configuration Reference
Variable | Default | Meaning |
|
| CLI executable name, or an absolute or relative path to the executable. |
| server current directory | Default workspace directory. |
| unset | Optional canonical root restricting permitted workspaces. |
|
| Default model slug. Precedence: per-call |
|
| Subagent / swarm worker model slug enforced via |
|
| Fast-tier model slug for batch tasks requesting |
|
| Reasoning-tier model slug for |
|
| Set to |
|
| Set to |
|
| Tool surface filter: |
|
| Maximum simultaneous CLI child processes (1–32). |
|
| Maximum characters in MCP tool response representation (1024–1000000; 16000 recommended). |
|
| Cumulative |
|
| Maximum captured CLI stdout buffer per process before termination (1024–67108864). |
|
| Set to |
|
| Command guard ( |
|
| Per-conversation environment isolation mode ( |
|
| Root directory for per-conversation isolated environments (pruned after 24h at startup). |
|
| MCP Tasks extension ( |
| unset | Optional directory for artifact store and telemetry (defaults to XDG state/cache path). |
Development
pnpm install --frozen-lockfile
pnpm check
pnpm test
pnpm format:checkSee CONTRIBUTING.md and SECURITY.md before filing issues or pull requests. Released under the Apache License 2.0.
Available Tools
3 toolsantigravity_continueContinue AntigravityADestructive
Follow up in an existing Antigravity conversation. Different explicit conversation_ids can run in parallel; simultaneous continuations of the same ID return BUSY. Without an ID, agy resumes its most recent conversation and requires exclusive access to this server, otherwise BUSY is returned. Other CLI sessions may change the latest conversation. Use the same workspace as the original turn.
Inputs: prompt (required), mode, model, effort, +4 more.
antigravity_modelsList Antigravity modelsARead-onlyIdempotent
List available model slugs and display names using agy models. Does not start a model turn; may contact the Antigravity service.
Inputs: no named parameters.
antigravity_runRun AntigravityADestructive
Start one Antigravity CLI turn in a new conversation. Useful for repository research, a second opinion, and explicitly requested edits. Returns a conversation_id for follow-up. Up to 4 agy calls can run concurrently per server; excess calls return BUSY. Parallel calls share workspace files and your existing Antigravity account and quota.
Inputs: prompt (required), mode, model, effort, +3 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
Each tool has a distinct purpose: run starts a new conversation, continue follows up on an existing one, and models lists available models. There is no overlap or ambiguity between them.
All tools use the consistent 'antigravity_' prefix followed by a clear verb (run, continue, models). The naming pattern is uniform and predictable.
Three tools is an ideal size for this server's scope: it provides the essential operations for interacting with the Antigravity CLI (start, continue, list models) without unnecessary bloat or missing functionality.
The server covers the full lifecycle of an Antigravity turn: starting a new conversation, continuing it, and discovering available models. Given its focused purpose, there are no obvious gaps.
Related MCP Connectors
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
Connect ChatGPT and Claude to your Mac, Windows or Linux with secure MCP remote access.
Chat, image, video, and audio models from many vendors behind one remote MCP server and one key.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables MCP-compatible clients like Codex to delegate tasks to the Antigravity CLI, using ConPTY on Windows to reliably capture responses.8MIT
- AlicenseNot gradedqualityDmaintenanceEnables MCP-compatible coding agents to run the local Antigravity CLI as a coding agent, manage conversation context and common options, and inspect usage, quota, models, version, help, and read-only slash commands.MIT
- AlicenseAqualityCmaintenanceEnables AI harnesses to delegate code analysis, modification, testing, and long-running tasks to the locally installed Antigravity CLI via stdio MCP, with job status tracking and conversation continuity.3MIT
- AlicenseBqualityCmaintenanceExposes the Antigravity CLI to MCP clients for structured planning, code review, test validation, general prompts, and literal slash commands against Google Gemini models.5MIT