codex-agy-bridge

by varadfromeast

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.8
Disambiguation5/5
Each tool targets a distinct operation or resource: admin actions, authentication, reviews on branches and commits, and run lifecycle management. Overlaps (e.g., review_branch vs review_commit) are clearly scoped.
Naming Consistency4/5
All tools share the prefix 'agy_' , and most follow a noun_verb pattern (e.g., agy_review_branch, agy_run_start). However, agy_start_with_expected_file breaks the pattern, and there is slight inconsistency between agy_review_commit and agy_start_ variants.
Tool Count5/5
13 tools cover the core domains (runs, reviews, goals, admin, login) without being overwhelming. Each tool serves a distinct purpose, and the count feels well-scoped for the bridge's functionality.
Completeness3/5
The run and review lifecycle is well-covered, but goal management lacks update/delete operations and listing tools. Additionally, there is no tool to list existing runs or reviews, which may force agents to rely on observe or wait with limited context.
Average 3.1/5 across 13 of 13 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 1 community issues answered or closed in the last 6 months
- 53 commits in the last 12 weeks
- Last stable release on July 20, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description fails to disclose behavioral traits such as whether actions are destructive, require authentication, or have side effects on the system. For an admin tool, this lack of transparency is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, making it concise but lacking structure. It front-loades the core purpose but omits any breakdown of actions, parameters, or usage examples, which would improve usability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, no schema descriptions, no annotations, output schema exists but not described), the description is far too minimal. It does not cover essential aspects like available actions, parameter roles, or return value, leaving the agent underinformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the description does not explain any of the five parameters (action, run_id, refresh, path, workspace). The agent gets no additional meaning beyond the parameter names and types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool is for running diagnostics and metadata actions on the bridge and agy CLI, which distinguishes it from sibling tools focused on other operations like goals, login, and review. However, 'bounded diagnostics' is somewhat vague, preventing a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives like agy_run_start or agy_review_commit. The description only notes the scope (bridge and agy CLI), leaving the agent to infer usage context without clear exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It reveals that 'dangerously_skip_permissions must be true when supplied' but doesn't disclose side effects, destructive potential, or behavior of each action. The term 'Manage' is vague.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Very short (2 sentences), but the first sentence is functional and the second provides a constraint. However, it sacrifices necessary detail for brevity, making it insufficiently informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 12 parameters and no parameter descriptions, the description is incomplete. It does not cover return values, per-action behavior, or default behaviors beyond the dangerous_permissions note.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description adds no meaning to the 12 parameters except a note about one parameter. It fails to explain what each parameter does or how they relate to the actions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States it manages bridge scheduler goals and lists specific actions (create, start_target, status), which clearly identifies the tool's purpose and distinguishes it from sibling tools like agy_run_start and agy_review_branch.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The only usage hint is about 'dangerously_skip_permissions', but it doesn't explain when to choose agy_goal over agy_run_* or agy_review_* tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior. It only mentions refresh and opening a login session without explaining side effects, prerequisites, or whether it's interactive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, but it lacks sufficient detail. While front-loaded, it sacrifices completeness for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 4 optional parameters, no schema descriptions, and no annotations, the one-line description is grossly inadequate for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain any of the four parameters. The parameter names give hints, but the tool definition adds no explicit meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool refreshes auth state and optionally opens a login session, using specific verbs and resources. It distinguishes from sibling tools which focus on reviews, runs, and admin tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, such as when a login session is needed or how it relates to other auth-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description reveals one key behavior (waits for file non-empty) but lacks details on async behavior, return, side effects, or permissions. With no annotations, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no wasted words, front-loaded with action and condition. Highly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lacks explanation of return values (output schema exists but not described), prerequisites, or behaviors beyond the file condition. Inadequate for a multi-parameter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and description adds no meaning to any of the 9 parameters. Agent must infer from parameter names only.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool starts a run that blocks until a file is non-empty. The verb 'start' and resource 'run' are specific, and the condition distinguishes it from sibling tools like agy_run_start, though not explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as agy_run_start or agy_goal. The description only defines behavior, not usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description indicates a destructive action (cancel, terminate) but lacks details on permissions, reversibility, side effects, or what happens to the process group.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single concise sentence, but it omits necessary details about usage and behavior. More information could be added without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no nested objects, the description is incomplete: it lacks explanation of the parameter, expected state of the run (must be active), and the nature of the response despite an output schema existing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (run_id) with 0% schema description coverage. The description does not explain what run_id is, its format, or how to obtain it, relying solely on the parameter name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool cancels an active Run and terminates its Antigravity process group, using specific verb and resource. It distinguishes from siblings like agy_run_start or agy_run_wait.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use cancel versus other run operations (e.g., agy_run_wait, agy_run_observe). No prerequisites or conditions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It mentions event waiting and condition values but does not explain blocking behavior, timeout handling, error scenarios, or whether it is destructive. This is insufficient for a waiting tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: two sentences. The first sentence clearly states the purpose, and the second provides key details about run_ids and conditions. No unnecessary text, though more structure could improve readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, the description does not need to detail return values. However, it lacks sufficient context to fully differentiate from siblings like agy_run_observe or agy_run_result. The condition aliases are helpful but overall completeness is moderate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It explains run_ids (always a list) and lists condition values, but does not describe the 'after' parameter or timeout_seconds beyond default. Only partial parameter guidance is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Wait for sparse Run events instead of repeatedly polling status.' It differentiates from polling tools and siblings like agy_run_cancel or agy_run_result by focusing on event-driven waiting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description suggests using this tool to avoid polling but does not provide explicit when-to-use or when-not-to-use guidance. It lists condition aliases, which helps, but no mention of alternatives like agy_run_observe.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description should disclose behavioral traits. It mentions 'Validate and summarize,' which indicates read-like operations, but it doesn't clarify if the tool is idempotent, requires specific permissions, or what happens on invalid input. The output schema exists but doesn't cover behavior beyond return values.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long and front-loads purpose. It is concise and avoids extraneous information, though it could include more behavioral details without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, return values are covered elsewhere. The description states what the tool does and when to use it, but lacks details on prerequisites, safety, and error handling. For a tool with one parameter and no annotations, it is minimally complete but has gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must add meaning for the single parameter 'run_id.' However, the description does not explain how to obtain the run_id, its format, or any constraints beyond the schema's type and requirement. No additional semantic value is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool validates and summarizes an artifact from a typed review run. It differentiates from siblings like agy_run_result by specifying it's for 'typed review Run' and mentions agy_review_commit/agy_review_branch as preferred inputs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says it is the 'Preferred way to consume completed agy_review_commit/agy_review_branch runs,' providing clear context on when to use this tool. It implies not to use for other run types, though it doesn't explicitly state alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. It mentions 'stale-write guards' but does not explain what they do when triggered (e.g., error handling, idempotency). No mention of side effects or prerequisites like authentication.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the main action and key feature. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite an output schema existing, the tool has 5 parameters with 0% schema coverage in the description. The description omits details about parameter types, constraints, and the stale-write guard mechanism, making it incomplete for an agent to use correctly without additional knowledge.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It only mentions the core action and 'stale-write guards' vaguely. Parameters like expected_event_key and expected_transcript_step are not explained, leaving ambiguity about their purpose and format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Send input'), the target resource ('a live foreground Run'), and a specific feature ('optional stale-write guards'). It distinguishes from sibling tools like agy_run_cancel or agy_run_observe by focusing on input delivery.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'live foreground Run' implies it should be used only when a run is active, but there is no explicit guidance on when to use this tool versus alternatives like agy_run_start or agy_run_result. The description lacks explicit when-to-use and when-not-to-use instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden. It discloses the main behavioral trait: offset_bytes enables bounded chunk reading. However, it does not state whether the operation is idempotent, what happens if the run is incomplete, or any rate limits or size constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that is front-loaded with the core purpose. Every word is necessary; there is no redundancy or verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema (no need to explain return values), the description adequately covers the two operation modes. However, it lacks lifecycle context (e.g., that it should only be called after a run completes) and does not mention the relationship to other run-related tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should explain parameters. It only mentions offset_bytes's role (bounded chunk) but does not clarify run_id (required identifier) or max_bytes (default chunk size). The description adds limited value beyond the schema structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads final result metadata and distinguishes two modes: full read or chunked read when offset_bytes is set. The verb 'Read' and resource 'final result metadata' are specific, and it differentiates from sibling tools like agy_run_input or agy_run_observe.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., that the run must be completed), nor does it contrast with similar siblings like agy_run_observe or agy_review_result.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavioral traits. It implies the tool is asynchronous by advising to wait for completion, and suggests not polling excessively. However, it does not explicitly state whether the tool is read-only or destructive, missing an opportunity to add transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: a single clear sentence for purpose followed by three instructional sentences. It is well-structured and front-loaded, though a more organized format could improve readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (12 parameters, async, multiple siblings), the description lacks completeness. It provides workflow guidance but omits parameter explanations and does not clarify the meaning of 'typed review Run.' With an output schema present, return values are covered, but parameter semantics are entirely missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning no parameter descriptions in the input schema. The description does not explain any of the 12 parameters, including the required 'issue' and 'workspace,' nor does it define 'scope_paths' despite mentioning it. With low coverage, the description should compensate, but it fails to do so.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Start a typed review Run for branch and working-tree changes,' specifying the verb (start), resource (review run), and context (branch and working-tree changes). This effectively distinguishes it from sibling tools like agy_review_commit and agy_review_result.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Keep issue focused and use narrow scope_paths when possible,' and outlines the workflow: 'Wait for completion with agy_run_wait, then prefer agy_review_result.' It also advises against frequent agy_run_observe calls, offering clear when-to-use and alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries the burden. It discloses async behavior ('return immediately') and hints at no manual polling, but omits side effects (e.g., file creation) or authorization needs. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each with a distinct purpose: action, guidance, post-run instruction. No redundancy, tightly packed with useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite an output schema (context signal), the description fails to address the complexity of 11 parameters. Missing prerequisites, return behavior beyond 'return immediately', and relationship to siblings like agy_login for auth. Incomplete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the description explains none of the 11 parameters. Only 'scope_paths' is hinted at. With zero parameter elaboration, the agent cannot understand inputs beyond names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Start a typed review Run for one commit and return immediately.' It specifies the resource (review run for a commit) and distinguishes from siblings like agy_review_branch (branch) and agy_review_result (result retrieval).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance: 'Keep issue focused and use narrow scope_paths when possible' advises on tool usage; 'prefer agy_review_result over manually polling raw artifacts' directs to a sibling for downstream actions. Clear when-to-use and what-not-to-do.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full burden. It implies read-only through 'inspect' and 'observation', but does not explicitly state non-destructiveness or any side effects. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with purpose, then parameter details. No redundancy or fluff. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the description lacks coverage for most parameters (9 out of 11). The tool is complex with many configuration options, but only the view parameter is well explained. Incomplete guidance for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so description must compensate. It explains 'run_ids' cardinality and all 'view' values, but leaves 9 other parameters (like 'after', 'limit', 'compact') completely unexplained. Only 2 of 11 parameters are addressed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it is for inspecting run state, with specific view options. It distinguishes from sibling tools that perform actions like cancel, start, or wait, by focusing on observation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on when to use different views: 'full' for multiple run_ids, others for exactly one. However, it does not explicitly compare to sibling tools or state when to choose this over them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. It reveals that the tool runs in the foreground, supports two modes, and requires dangerously_skip_permissions. However, it lacks details on side effects, resource creation, blocking behavior, or what happens after invocation (e.g., whether it returns immediately or waits).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph with three sentences, no wasted words. It front-loads the main purpose and then details key parameters. It is concise but could benefit from bullet points or clearer separation of mode behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 9 parameters (2 required), no schema descriptions, and an output schema, the description is not fully complete. It covers key concepts but omits important context like whether the run is synchronous, how to handle timeouts, and the meaning of optional parameters like sandbox. The output schema exists but the description does not hint at the return shape.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate. It explains 'mode', 'conversation_id', and 'dangerously_skip_permissions' but leaves 'prompt', 'workspace', 'timeout_seconds', 'model', 'sandbox', and 'additional_directories' unexplained. This partial coverage is adequate but incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool starts or continues a foreground Antigravity Run, with verbs 'start' and 'continue'. It distinguishes between modes ('task' vs. 'interactive') and mentions continuing via conversation_id. The purpose is unambiguous and distinguishable from sibling tools like agy_run_cancel or agy_run_wait.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides specific guidance on when to use each mode: 'task' for normal tasks and 'interactive' for persistent conversations 'sparingly'. It also notes that dangerously_skip_permissions must be true. However, it does not explicitly state when not to use this tool versus other run-related siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![codex-agy-bridge MCP server](https://glama.ai/mcp/servers/varadfromeast/codex-agy-bridge/badges/card.svg)](https://glama.ai/mcp/servers/varadfromeast/codex-agy-bridge)

Score Badge

Copy to your README.md:

[![codex-agy-bridge MCP server](https://glama.ai/mcp/servers/varadfromeast/codex-agy-bridge/badges/score.svg)](https://glama.ai/mcp/servers/varadfromeast/codex-agy-bridge)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/varadfromeast/codex-agy-bridge'

If you have feedback or need assistance with the MCP directory API, please join our Discord server