agy-bridge
The agy-bridge server is an MCP bridge that lets Claude Code delegate heavy, context-intensive tasks to the Antigravity CLI (agy), routing them to powerful models (Gemini, Claude Opus, GPT) so large files, deep searches, and web lookups never consume Claude's context window.
Core capabilities:
analyze_files: Delegate analysis of large files (>200 lines) or multiple files (>3 at once) — logs, database dumps, generated code, cross-file comparisons — without loading them into Claude's context.deep_search: Perform codebase archaeology (git log/diff/blame, repo-wide greps, historical change investigations) without running many commands yourself.web_lookup: Fetch library docs, API references, error messages, current package versions, or any external/up-to-date knowledge via web access.adversarial_review: Get a critical second opinion from a different model family on plans, designs, diffs, or code — hunting for flaws, edge cases, security issues, and unstated assumptions.follow_up: Continue a previousagysession bysession_idwithout resending prior context, enabling multi-turn conversations with full session continuity.delegate: Raw delegation of any heavy or miscellaneous task toagy, which has full tool access (shell, file reads, web) within the specified working directory.
Additional features:
Automatic model routing with availability detection and fallback chains.
Quota-aware failover: Detects
429 RESOURCE_EXHAUSTEDerrors, kills hung processes, and retries on the next available model.Configurable timeouts per tool, with environment variable overrides.
Output truncation (configurable via
AGY_MAX_OUTPUT_CHARS, default 50,000 chars) to protect Claude's context.Strict failure mode (
AGY_ON_FAILURE=strict) to prevent Claude from silently absorbing failed delegations.
agy-bridge
An MCP bridge that lets Claude Code delegate heavy tasks to the Antigravity CLI (agy) — saving Claude's context window and tokens for what matters.
Claude sends a task → the bridge routes it to the best available model via agy → only the answer comes back. Large files, deep git searches, and web lookups never touch Claude's context.
Listed on
User → Claude Code → agy-bridge (MCP) → agy CLI → Gemini / Claude / GPT-OSS
← ← ←Why this over claude-to-agy?
claude-to-agy | agy-bridge | |
Tool surface | 1 generic | 6 purpose-built tools — Claude self-routes reliably |
Model selection | none (agy default only) | per-tool routing across all |
Multi-turn | stateless | session continuity — |
Output safety | unbounded | configurable truncation cap protects Claude's context |
Sandbox | no | optional |
Install | uvx (Python) | npx (Node) — zero install |
Related MCP server: codex-agy-bridge
Requirements
Node.js 18+
Antigravity CLI (
agy) installed and authenticated
Install
# 1. Register the MCP server (user scope = all projects).
# add-json bakes in a generous client-side timeout so long analyze_files /
# delegate calls don't trip Claude Code's tool-call deadline (see Timeouts).
claude mcp add-json -s user agy-bridge \
'{"command":"npx","args":["-y","agy-bridge"],"timeout":600000}'
# 2. Add delegation rules to your project (or ~/.claude/CLAUDE.md for global)
curl -o CLAUDE.md https://raw.githubusercontent.com/sshahzaiib/agy-bridge/main/CLAUDE.mdThe
"timeout": 600000(10 min, milliseconds) is the client-side tool-call deadline — without it, a cold-startanalyze_files(~40–50s) or a longdelegatecan hit Claude Code's default and returntimed out waiting for responsewhile the agy run is still going. If your client doesn't honor a per-servertimeout, set the global env varMCP_TOOL_TIMEOUT=600000instead. Details and the agy-side budgets are in Timeouts and cancellation.
Tools
Tool | Use for | Model routing (first available) |
| Files >200 lines, >3 files at once, logs, dumps, generated code | Gemini 3.5 Flash (High) → Gemini 3.1 Pro (Low) |
| git log/diff/blame archaeology, repo-wide greps | Gemini 3.5 Flash (Medium) → (High) |
| Docs, API references, external/current knowledge | Gemini 3.5 Flash (Medium) → (High) |
| Plan critiques, design and code reviews | Gemini 3.1 Pro (High) → Claude Opus 4.6 (Thinking) → Flash (High) |
| Continue a prior session by | inherits the session |
| Anything else heavy | Gemini 3.5 Flash (High) |
All tools accept optional cwd (project root) and model (exact name from agy models; validated, with available models listed on mismatch).
Every response ends with a footer:
---
[agy-bridge] model: Gemini 3.5 Flash (High) | session: 1f0c…-d4 (use follow_up to continue)Model routing
On first use the bridge runs agy models (cached for the process lifetime) and picks the first available model in the tool's preference chain. If none is available it falls back to AGY_DEFAULT_MODEL, and finally to agy's own default. agy silently ignores unknown --model values, so the bridge validates names up front instead of letting requests land on the wrong model.
Quota-aware failover
agy never surfaces quota exhaustion in print mode — it silently retries the 429 until its print-timeout, then exits 0 with empty output, which used to look like an indefinite hang. The bridge now watches each run's log file (via --log-file) and on RESOURCE_EXHAUSTED (code 429):
kills the agy process group immediately (no waiting out the timeout),
parses the reset time ("Resets in 4h24m") into an in-process cooldown registry,
retries the same prompt on the next model in the tool's chain,
skips cooled-down models on all subsequent calls until their quota resets.
Failovers are annotated in the response footer (failover: <model>: quota exhausted (resets in 4h24m)). Only when every candidate is exhausted does the call fail — in seconds, with reset times listed — instead of hanging.
Timeouts and cancellation
Each tool has its own default timeout sized to its job: web_lookup 120s, deep_search 180s, analyze_files / adversarial_review / follow_up 300s, delegate 600s. Setting AGY_TIMEOUT explicitly overrides all of them at once. To change a single tool, set AGY_TIMEOUT_<TOOL_NAME> instead (e.g. AGY_TIMEOUT_DEEP_SEARCH=300); a per-tool override takes precedence over the global AGY_TIMEOUT and the tool's default. The full set of per-tool variables is AGY_TIMEOUT_ANALYZE_FILES, AGY_TIMEOUT_DEEP_SEARCH, AGY_TIMEOUT_WEB_LOOKUP, AGY_TIMEOUT_ADVERSARIAL_REVIEW, AGY_TIMEOUT_FOLLOW_UP, and AGY_TIMEOUT_DELEGATE. The kill path escalates SIGTERM → SIGKILL across the whole process group, and the deadline fires even if agy's helper processes hold the output pipes open. Cancelling the tool call from the MCP client (e.g. pressing Esc in Claude Code) also kills the agy run instead of orphaning it.
Two timeout layers — align them. The timeouts above are the agy-side budget. Your MCP client (Claude Code) has its own, separate tool-call timeout, and if it is shorter than the agy budget the client gives up first — you'll see Error: timed out waiting for response (note: agy-bridge's own timeout reads agy timed out after Ns instead). The work is not lost: the agy session persists, so follow_up with the returned session_id retrieves the result. But the real fix is to make the client wait at least as long as agy: the Install command already sets a per-server timeout of 600000ms (scoped to the agy-bridge entry only). If you registered the server without it, re-run the add-json command from Install, or set the global env var MCP_TOOL_TIMEOUT=600000. Rule of thumb: client timeout ≥ agy budget.
Expected latency. Most of the perceived "slowness" is cold start: the first call in a session spawns the agy CLI and warms the model. A simple analyze_files over 3 files measures around 40–50s cold (≈46s observed), dropping on subsequent same-session calls. A first call that also hits a quota 429 takes longer while the bridge fails over. So a client timeout below ~60s will intermittently trip on cold starts even for "simple" questions — size it generously.
Configuration
All optional, via environment variables:
Variable | Default | Description |
|
| Path to the agy binary |
| per-tool | Seconds; overrides all per-tool timeouts at once (see above), passed as |
| per-tool | Seconds; overrides the timeout for a single tool only, e.g. |
|
| Truncation cap for tool output |
| unset | Fallback model when no chain entry is available |
|
| Pass |
|
| Run agy with |
|
|
|
Failure behavior
The bridge always fails loudly: agy errors surface as MCP tool errors with agy's actual stderr, and degraded model routing is annotated in the response footer. By default the calling agent (Claude) will typically do the work itself after a failure — visible in the transcript, but easy to stop noticing in a long session. Set AGY_ON_FAILURE=strict to append an explicit "do NOT perform this work yourself — report the failure to the user" instruction to every delegation error, so you keep control over when token savings are silently lost.
Development
npm install
npm test # vitest unit tests (exec mocked — no agy needed)
npm run typecheck
npm run build # tsup → dist/index.jsContributors
Contributions are welcome — open an issue or PR.
Star History
License
MIT
Available Tools
6 toolsadversarial_reviewA
Get an adversarial second opinion from a different model family (Gemini Pro). ALWAYS use this for plan critiques, design reviews, and pre-merge code review: it hunts for flaws, edge cases, security issues, and unstated assumptions you may have missed.
| Name | Required | Description | Default |
|---|---|---|---|
| content | No | Inline content to review (plan, diff, code snippet). | |
| files | No | File paths to review instead of inline content. | |
| focus | No | Optional focus area, e.g. 'security', 'concurrency'. | |
| cwd | No | Absolute path to the working directory / project root. Defaults to the server's cwd. | |
| model | No | Override the model (exact name from `agy models`, e.g. "Gemini 3.1 Pro (High)"). Normally omit — the tool routes automatically. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It discloses that the tool uses a different model family (Gemini Pro) and that it hunts for flaws, edge cases, security issues, and unstated assumptions. This provides good insight into its behavior, though it does not mention side effects, cost, or time implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences that front-load the purpose and immediately provide usage guidance. Every sentence is valuable, and there is no redundant or extraneous text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's 5 optional parameters and no output schema, the description provides essential context on what the tool does and when to use it. However, it does not describe the output format or return value, which would be helpful for an agent to know what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with clear parameter descriptions. The tool description adds context on when to use the tool and what it does, which enhances understanding of the parameters (e.g., 'focus' is explained by the tool's purpose). This adds value beyond the schema, justifying a score above baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get an adversarial second opinion from a different model family (Gemini Pro).' It also distinguishes itself from siblings by specifying use cases: 'ALWAYS use this for plan critiques, design reviews, and pre-merge code review.' This provides a specific verb and resource with clear differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly recommends using the tool for plan critiques, design reviews, and pre-merge code review, and explains what it does ('hunts for flaws, edge cases, security issues, and unstated assumptions'). It does not explicitly state when not to use it, but the positive guidance is strong and distinguishes it from sibling tools like analyze_files or deep_search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
analyze_filesA
Delegate file analysis to the Antigravity CLI (Gemini) instead of reading files yourself. USE THIS whenever a file is large (>200 lines) or the task spans more than 3 files: logs, database dumps, generated code, cross-file reviews, comparisons. The files never enter your context — only the answer does.
| Name | Required | Description | Default |
|---|---|---|---|
| files | Yes | File paths to analyze (relative to cwd or absolute). | |
| question | Yes | What you want to know about these files. | |
| cwd | No | Absolute path to the working directory / project root. Defaults to the server's cwd. | |
| model | No | Override the model (exact name from `agy models`, e.g. "Gemini 3.1 Pro (High)"). Normally omit — the tool routes automatically. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Adds key behavioral note that 'files never enter your context — only the answer does,' but lacks details on whether the tool modifies files or other side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences plus a bold directive, front-loaded with purpose. Every sentence earns its place; no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, description covers purpose, usage guidelines, and a behavioral trait. Missing explicit details about return format, but adequate for a delegation tool with good schema documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. Description does not add extra meaning to parameters beyond what schema descriptions provide.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Delegate file analysis' as the verb+resource, and distinguishes from reading files yourself. It specifies the tool is for analyzing files via CLI, making the purpose highly clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use ('USE THIS whenever a file is large (>200 lines) or the task spans more than 3 files') with examples. Does not explicitly exclude sibling tools, but provides strong contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
deep_searchA
Delegate codebase archaeology to the Antigravity CLI: git log/diff/blame spelunking, wide greps across a repo, 'when/why did X change', 'where is Y used'. USE THIS instead of running many search commands yourself — it saves your context.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What to find, e.g. 'when was the auth middleware refactored and why'. | |
| cwd | No | Absolute path to the working directory / project root. Defaults to the server's cwd. | |
| model | No | Override the model (exact name from `agy models`, e.g. "Gemini 3.1 Pro (High)"). Normally omit — the tool routes automatically. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions delegating to an external CLI and lists git commands, but lacks details on side effects, permissions, or limitations. The description is adequate but could be more explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three concise sentences, front-loading the purpose and use case. Every sentence adds value, and the structure is efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose and usage well, but lacks details on output format or potential limitations (e.g., timeouts). However, given the tool's search nature and lack of output schema, this is acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents parameters well. The description adds context through example queries but does not significantly enhance the parameter descriptions beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs codebase archaeology using git commands and grep, with specific examples like 'when/why did X change'. It effectively differentiates from sibling tools, none of which are similar search tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises using this tool instead of running many search commands manually to save context. While it doesn't state when not to use it, the guidance is clear and helpful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
delegateA
Raw delegation to the Antigravity CLI for heavy tasks that don't fit the other tools. agy has full tool access (shell, file reads, web) in the given cwd.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | The complete task prompt for agy. | |
| cwd | No | Absolute path to the working directory / project root. Defaults to the server's cwd. | |
| model | No | Override the model (exact name from `agy models`, e.g. "Gemini 3.1 Pro (High)"). Normally omit — the tool routes automatically. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, description discloses that 'agy has full tool access (shell, file reads, web) in the given cwd.' This warns the agent about powerful capabilities, though it could mention potential side effects or explicit destructive behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no wasted words. Front-loaded with purpose and usage, immediately informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a delegation tool with powerful capabilities, the description covers purpose, usage, and what the CLI can do. Lacks details on error handling or output format, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover 100% of parameters, so baseline is 3. Description adds no extra meaning beyond the schema; each parameter is already sufficiently described in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool's purpose: 'Raw delegation to the Antigravity CLI for heavy tasks that don't fit the other tools.' It specifies the verb (delegate), resource (Antigravity CLI), and distinguishes from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides guideline: 'for heavy tasks that don't fit the other tools.' This tells when to use it but does not explicitly state when not to use it or name alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
follow_upA
Continue a previous Antigravity session by session_id (returned by every other tool). USE THIS for follow-up questions about a prior delegation — the full prior context is already on agy's side, so you don't resend anything.
| Name | Required | Description | Default |
|---|---|---|---|
| session_id | Yes | The session id returned by a previous agy-bridge call. | |
| question | Yes | The follow-up question. | |
| cwd | No | Absolute path to the working directory / project root. Defaults to the server's cwd. | |
| model | No | Override the model (exact name from `agy models`, e.g. "Gemini 3.1 Pro (High)"). Normally omit — the tool routes automatically. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears full burden. It discloses that the prior context is already on the server side, reducing data transfer, but does not mention potential behaviors like session expiration, idempotency, or error conditions. This is adequate but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise: two sentences delivering purpose, usage direction, and behavioral hint with zero wasted words. Information is front-loaded and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (4 params, no output schema, no annotations), the description covers what the tool does, when to use it, and a key behavioral trait (no resending). It does not explain return format or error scenarios, but for a follow-up tool this is mostly sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already describes all four parameters. The description adds no new semantic information beyond what the schema's descriptions provide (e.g., session_id's origin, question's purpose). Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's purpose: continuing a previous Antigravity session via session_id for follow-up questions. It specifies the resource (session) and action (continue), and the note about not resending context differentiates it from starting new delegations, though explicit sibling differentiation is minimal.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly directs use for follow-up questions after a prior delegation, and explains the benefit (no resending context). However, it does not explicitly state when to use alternatives like 'delegate' for new tasks, leaving some inference required.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
web_lookupB
Delegate a web/documentation lookup to the Antigravity CLI (Gemini with web access): library docs, API references, error messages, current versions, external knowledge. USE THIS when you need information you don't have or that may be newer than your training data.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What to look up on the web. | |
| cwd | No | Absolute path to the working directory / project root. Defaults to the server's cwd. | |
| model | No | Override the model (exact name from `agy models`, e.g. "Gemini 3.1 Pro (High)"). Normally omit — the tool routes automatically. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions delegation to Antigravity CLI but lacks disclosure of behavioral traits such as side effects, permissions, latency, failure behavior, or rate limits. Given the external web access, more transparency is expected.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the tool's purpose and examples. It is efficient, though the first sentence is dense and could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description explains the tool's purpose and provides usage guidance, but lacks information about return values (no output schema) and error handling. Given the absence of annotations, it is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters with descriptions. The description adds no additional meaning beyond the schema (e.g., it does not elaborate on query format or cwd usage). Baseline score of 3 is appropriate given full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool delegates web/documentation lookups to an external CLI for library docs, API references, etc. It specifies the verb 'delegate' and the resource 'web/documentation lookup', and provides a usage hint. However, it does not explicitly differentiate from sibling tools like deep_search or delegate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'USE THIS when you need information you don't have or that may be newer than your training data,' providing clear context for when to use the tool. It does not mention when not to use it or list alternatives, but the guidance is sufficient for most cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose: adversarial review, file analysis, codebase search, generic delegation, session follow-up, and web lookup. No overlap or ambiguity.
All tool names follow a consistent snake_case pattern with descriptive verbs and nouns (e.g., adversarial_review, analyze_files). No mix of styles.
With 6 tools, the server is well-scoped for its role as a bridge to a CLI, covering common delegation needs without excess or deficiency.
The tool set provides complete coverage for the intended purpose: specialized delegation for review, file analysis, search, and web lookup, plus a generic delegate and follow-up for continuity.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Source-checked CLI guides and model-aware planning for Claude Code, Codex, and Grok Build.
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
One MCP endpoint for Claude, GPT & Gemini: 100+ tools + no-code connectors + agent workers.
No-data MCP handoff for local Claude Code to Codex harness moves. $49 lifetime.
Related MCP Servers
- AlicenseBqualityAmaintenanceA lightweight MCP bridge that lets Claude Code delegate heavy tasks to the Antigravity CLI - saving context window and tokens for what matters.112MIT
- AlicenseBqualityAmaintenanceAn MCP bridge that lets Codex delegate long-running agent work to the Antigravity CLI, providing observable and resumable tool-based execution with project scoping.137MIT
- AlicenseNot gradedqualityCmaintenanceMCP bridge for calling local coding-agent CLIs (Codex, Claude) from another agent, enabling bounded tasks like code review, verification, and bug hunting.MIT
- AlicenseAqualityCmaintenanceWraps Google's Antigravity CLI as MCP tools for Claude, enabling cost-disciplined multi-model execution with background jobs and fan-out research/review pipelines.13MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/sshahzaiib/agy-bridge'
If you have feedback or need assistance with the MCP directory API, please join our Discord server