A2A MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Each tool has a clearly distinct purpose with no overlap: cancel_task, get_task_result, list_agents, register_agent, send_message, send_message_stream, and unregister_agent all target specific operations in the A2A agent management workflow. The two message-sending tools are differentiated by streaming vs. non-streaming behavior, avoiding confusion.
Naming Consistency5/5
All tools follow a consistent verb_noun naming pattern (e.g., cancel_task, get_task_result, list_agents, register_agent). The naming is uniform across all seven tools, using snake_case throughout without any deviations or mixed conventions.
Tool Count5/5
With 7 tools, the server is well-scoped for managing A2A agents and tasks. Each tool earns its place by covering essential operations like agent registration, message sending, task management, and result retrieval, without being overly sparse or bloated.
Completeness4/5
The tool set provides strong coverage for core A2A agent workflows, including agent lifecycle (register/unregister/list), task management (cancel/get result), and communication (send message with and without streaming). A minor gap exists in lacking a tool to directly list or manage tasks without prior knowledge of task IDs, but agents can work around this using existing tools.
Average 3.3/5 across 7 of 7 tools scored.
See the Tool Scores section below for per-tool breakdowns.
This repository is archived. Archived repositories automatically receive an F maintenance tier.
This repository is licensed under Apache 2.0.
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?
With no annotations provided, the description carries full burden but offers limited behavioral insight. It states the tool cancels a 'running task' and returns a 'cancellation result', but doesn't disclose critical details like required permissions, whether cancellation is reversible, potential side effects on the agent, or error conditions (e.g., invalid task_id). This is inadequate for a mutation tool with zero annotation coverage.
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 front-loaded with the core purpose, followed by structured Args and Returns sections. It's efficient with minimal waste, though the 'Returns' line is vague ('Cancellation result') and could be more informative without sacrificing brevity.
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's complexity (a mutation with no annotations) and schema richness (0% coverage, but has output schema), the description is partially complete. It covers the basic action and parameter, and the output schema may handle return values, but it lacks behavioral context, usage guidelines, and detailed parameter semantics, making it only minimally viable.
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?
Schema description coverage is 0%, but the description adds basic meaning by specifying 'task_id: ID of the task to cancel'. This clarifies the parameter's purpose beyond the schema's type definition. However, it doesn't provide format details (e.g., UUID), validation rules, or examples, leaving gaps given the low coverage.
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 action ('Cancel') and target ('a running task on an A2A agent'), providing specific verb+resource. However, it doesn't explicitly differentiate from sibling tools like 'get_task_result' or 'unregister_agent' that might also interact with tasks or agents, which prevents a perfect score.
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 guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., the task must be running), exclusions (e.g., cannot cancel completed tasks), or comparisons to siblings like 'get_task_result' for checking task status, leaving the agent with minimal context for decision-making.
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 provided, the description carries full burden but only states the basic action and return type. It doesn't disclose behavioral traits such as authentication requirements, potential side effects (e.g., agent becoming active), error conditions, or rate limits, which are critical for a registration 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 appropriately sized with two sentences and uses a structured 'Args' and 'Returns' format, making it easy to parse. However, the second sentence about returns is somewhat redundant given the output schema, slightly reducing efficiency.
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's moderate complexity (registration action with one parameter) and the presence of an output schema, the description covers basic purpose and parameters but lacks context on usage, behavior, and integration with siblings. It's minimally adequate but has clear gaps in completeness.
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 schema description coverage is 0%, but the description adds minimal semantics by naming the 'url' parameter and indicating it's for the A2A agent. However, it doesn't explain format constraints (e.g., HTTP/HTTPS), validation rules, or examples, leaving gaps despite the single parameter.
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 action ('Register') and resource ('an A2A agent with the bridge server'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'unregister_agent' or 'list_agents', which would be needed for a perfect score.
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 like 'unregister_agent' or 'list_agents'. The description lacks context about prerequisites, timing, or exclusions, leaving the agent with minimal usage direction.
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 carries the full burden. It states the action ('unregister') but doesn't disclose behavioral traits such as whether this is destructive (likely yes, but not confirmed), permission requirements, error conditions, or side effects. The return value is mentioned but not elaborated, leaving gaps in understanding the tool's behavior.
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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by brief sections for Args and Returns. There's no wasted text, though the structure could be more integrated (e.g., combining purpose with parameter context).
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's complexity (a mutation with no annotations), the description is moderately complete. It covers the purpose and parameter role, and an output schema exists, so return values don't need explanation. However, it lacks critical context like when to use, behavioral risks, or error handling, making it adequate but with clear gaps for safe invocation.
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?
Schema description coverage is 0%, but the description adds minimal semantics: it notes that 'url' is the 'URL of the A2A agent to unregister'. This clarifies the parameter's role beyond the schema's type definition. However, with only one parameter and no format details (e.g., expected URL structure), it partially compensates but doesn't fully address the coverage gap.
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: 'Unregister an A2A agent from the bridge server.' It specifies the verb ('unregister') and resource ('A2A agent'), distinguishing it from siblings like 'register_agent' and 'list_agents'. However, it doesn't explicitly differentiate from 'cancel_task' or 'send_message' in terms of domain scope.
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 guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., agent must be registered first), exclusions, or compare it to siblings like 'cancel_task' or 'list_agents'. The agent must infer usage from the name alone.
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 carries full burden. It mentions the return type ('List of registered agents'), which is helpful, but lacks details on permissions, rate limits, pagination, or error handling. For a read operation with zero annotation coverage, 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?
The description is front-loaded with the core purpose in the first sentence, followed by a brief return statement. Both sentences earn their place, and there's no wasted text.
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's simplicity (0 parameters, has output schema), the description is adequate but incomplete. It covers the basic purpose and return value, but lacks behavioral context like permissions or usage scenarios, which would be needed for a higher score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description doesn't need to add parameter details, and it doesn't introduce unnecessary complexity.
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 verb ('List') and resource ('all registered A2A agents'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_task_result' or 'register_agent', which would require 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 guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context for listing agents, or relationships to sibling tools like 'register_agent' or 'unregister_agent'.
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 provided, the description carries full burden for behavioral disclosure. It mentions what the tool returns (status, message, artifacts) but doesn't cover important aspects like error handling (what happens with invalid task_id), authentication requirements, rate limits, or whether this is a read-only operation. For a tool that retrieves potentially sensitive task results, this leaves significant behavioral gaps.
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 perfectly structured and concise. It opens with a clear purpose statement, then provides organized sections for Args and Returns with bullet-like formatting. Every sentence earns its place by adding essential information without redundancy or fluff. The information is front-loaded with the core purpose first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no annotations, but has output schema), the description does well. The output schema existence means it doesn't need to detail return values, and the description covers parameter meanings adequately. However, for a task result retrieval tool in an A2A agent context, it could benefit from mentioning typical use cases or integration patterns with sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides meaningful context for both parameters beyond the schema's 0% coverage. It explains that 'task_id' identifies which task to retrieve and that 'history_length' controls how many history items to include (with null meaning all). This adds crucial semantic understanding, though it doesn't specify format constraints for task_id or valid ranges for history_length.
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 action ('Retrieve the result of a task') and resource ('from an A2A agent'), making the purpose immediately understandable. It distinguishes this tool from siblings like 'cancel_task' or 'send_message' by focusing on result retrieval rather than task management or communication. However, it doesn't explicitly contrast with potential alternatives for getting task information, keeping it from a perfect score.
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 implies usage when you need to check the outcome of a previously submitted task, but provides no explicit guidance on when to use this versus alternatives. There's no mention of prerequisites (e.g., needing a valid task_id from a prior operation) or when not to use it. The context is clear but lacks specific usage rules or comparisons with sibling 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?
No annotations are provided, so the description carries the full burden. It mentions that the tool returns a 'task_id for future reference', which hints at asynchronous behavior, but fails to disclose critical details like authentication requirements, rate limits, error handling, or whether this is a blocking call. For a communication tool with zero annotation coverage, this is a significant gap in behavioral context.
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 efficiently structured with a clear opening sentence followed by labeled 'Args' and 'Returns' sections. Every sentence earns its place by providing essential information without redundancy, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers the purpose, parameters, and return value, and the output schema likely details the response structure, reducing the need for further explanation. However, it could better address behavioral aspects and sibling tool differentiation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates well by explaining all three parameters: 'agent_url' as the URL of the A2A agent, 'message' as the content to send, and 'session_id' as optional for multi-turn conversations. This adds meaningful context beyond the bare schema, though it doesn't specify formats or constraints for these parameters.
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 verb 'send' and the resource 'message to an A2A agent', making the purpose explicit. However, it doesn't distinguish this tool from its sibling 'send_message_stream', which likely handles streaming responses, leaving some ambiguity about when to choose one over the other.
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 implies usage for sending messages to A2A agents, with the optional 'session_id' hinting at multi-turn conversations. However, it lacks explicit guidance on when to use this tool versus 'send_message_stream' or other siblings like 'list_agents', and doesn't mention prerequisites or exclusions, leaving usage context somewhat vague.
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 full burden. It discloses the streaming behavior and optional session management for conversations, which are valuable behavioral traits. However, it doesn't mention authentication requirements, rate limits, error conditions, or what happens when streaming fails—significant gaps for a network operation tool.
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 perfectly structured with a clear purpose statement followed by organized Args and Returns sections. Every sentence earns its place by providing essential information without redundancy. The front-loaded purpose statement immediately communicates the tool's core function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (network communication with streaming), no annotations, but with an output schema (implied by 'Returns: Stream'), the description does reasonably well. It covers the basic operation, parameters, and return type. However, it lacks details about error handling, streaming mechanics, or performance characteristics that would be helpful for complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/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 provides clear semantic meaning for all three parameters: 'agent_url' as the target URL, 'message' as the content to send, and 'session_id' for conversation continuity. This adds substantial value beyond the bare schema types, though it doesn't specify URL format or message constraints.
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 specific action ('Send a message to an A2A agent and stream the response'), identifies the resource (A2A agent), and distinguishes it from sibling 'send_message' by specifying the streaming behavior. This provides immediate differentiation from non-streaming alternatives.
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 implies usage context through the mention of 'multi-turn conversations' and streaming, suggesting this is for interactive scenarios where real-time responses are needed. However, it doesn't explicitly state when to choose this over the non-streaming 'send_message' or other alternatives like 'get_task_result'.
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:

[![A2A-MCP-Server MCP server](https://glama.ai/mcp/servers/GongRzhe/A2A-MCP-Server/badges/card.svg)](https://glama.ai/mcp/servers/GongRzhe/A2A-MCP-Server)

Score Badge

Copy to your README.md:

[![A2A-MCP-Server MCP server](https://glama.ai/mcp/servers/GongRzhe/A2A-MCP-Server/badges/score.svg)](https://glama.ai/mcp/servers/GongRzhe/A2A-MCP-Server)

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/GongRzhe/A2A-MCP-Server'

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