Back-Agent MCP Server

by ZUENS2020

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v2.0.5
Disambiguation3/5
There is significant overlap between create-task and execute-task, both described as spawning Claude Code AI for development tasks with similar capabilities and limitations, which could cause confusion. However, other tools like cancel-task, delete-task, get-task-result, get-task-status, list-tasks, and get-task-stats have clearer distinct purposes related to task management.
Naming Consistency4/5
Tool names follow a consistent verb-noun pattern with hyphens (e.g., create-task, get-task-status), making them predictable and readable. The only minor deviation is execute-task, which uses a different verb than the others but still fits the pattern.
Tool Count5/5
With 8 tools, the server is well-scoped for task management and AI programming assistance. Each tool has a clear role, such as creating, executing, monitoring, and managing tasks, which fits the server's purpose without being overly sparse or bloated.
Completeness4/5
The tool set covers the full lifecycle of tasks (create, execute, status, result, cancel, delete, list, stats), providing good coverage for task management. A minor gap is the lack of tools for updating or modifying tasks, but agents can work around this by recreating tasks if needed.
Average 3.4/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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, so the description carries the full burden of behavioral disclosure. It states the tool cancels tasks, implying a mutation operation, but lacks details on permissions needed, whether cancellation is reversible, side effects (e.g., on related resources), or error conditions. This is a significant gap 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It is appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration.
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 (a mutation operation), lack of annotations, and no output schema, the description is incomplete. It fails to address key contextual aspects like behavioral traits, usage scenarios, or what to expect upon cancellation, leaving significant gaps for an AI agent.
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 100%, so the schema already documents the single parameter 'taskId'. The description adds no additional meaning beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate.
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 pending or running task'), providing a specific verb+resource combination. It distinguishes the tool's purpose from siblings like 'delete-task' (removal) or 'execute-task' (initiation), though it doesn't explicitly mention these distinctions in the text.
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 like 'delete-task' or 'execute-task'. It mentions 'pending or running' tasks, which implies a context, but offers no explicit when/when-not rules, prerequisites, or named alternatives.
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 of behavioral disclosure. It states 'Get statistics about all tasks', which implies a read-only operation, but doesn't specify what kind of statistics (e.g., counts, averages, trends), whether it requires permissions, or how data is returned (e.g., format, pagination). This leaves significant 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Get statistics about all tasks.' It is front-loaded and wastes no words, making it easy to parse quickly. Every word earns its place by conveying the core action and scope.
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 complexity of statistical tools and the lack of annotations and output schema, the description is incomplete. It doesn't explain what statistics are returned (e.g., numerical summaries, charts), how they are aggregated, or any limitations. For a tool that likely provides detailed data, this minimal description fails to give enough context for effective use.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it could have clarified that no inputs are required. Baseline is 4 for zero parameters, as the schema fully covers the absence of inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get statistics about all tasks' clearly states the verb ('Get') and resource ('statistics about all tasks'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get-task-status' or 'get-task-result', leaving ambiguity about what specific statistics are provided versus status or result information.
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. With siblings like 'get-task-status', 'get-task-result', and 'list-tasks', there's no indication of whether this tool is for aggregated metrics, performance data, or other statistical insights, nor any prerequisites or exclusions 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 carries full burden. It mentions optional filtering but doesn't disclose important behavioral traits like pagination behavior (implied by 'limit' parameter), default sorting, whether it returns all tasks or only those accessible to the user, or any rate limits. The description is minimal and lacks necessary operational 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a simple list operation and front-loads the core functionality.
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 list operation with no annotations and no output schema, the description is insufficient. It doesn't explain what information is returned about each task, how results are structured, or important operational constraints. Given the context of multiple sibling tools for task management, more guidance is needed.
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 100%, so the schema already fully documents both parameters with descriptions and enum values. The description adds no additional parameter semantics beyond what's in the schema, meeting the baseline for high schema 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 verb ('List') and resource ('tasks') with optional filtering by status. It's specific about what the tool does, though it doesn't explicitly differentiate from sibling tools like 'get-task-stats' or 'get-task-status' which might also retrieve task information.
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. With siblings like 'get-task-stats', 'get-task-status', and 'get-task-result', there's no indication of when this list operation is preferred over those more specific retrieval 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 of behavioral disclosure. It mentions the action is for deletion but doesn't cover critical aspects like whether this is reversible, what permissions are required, if it affects related data, or what the response looks like. For a destructive operation with zero annotation coverage, this is a significant gap in 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 brief and to the point with two sentences, front-loading the core purpose. Every sentence adds value: the first states the action, and the second provides usage context. It could be slightly more structured by explicitly separating purpose from guidelines, but it's efficient with minimal waste.
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 as a destructive operation with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., irreversibility, permissions), response format, and error handling. For a delete tool, this leaves significant gaps in understanding how to use it effectively.
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 100% description coverage, with 'taskId' clearly documented as 'The task ID.' The description doesn't add any extra meaning about the parameter beyond what the schema provides, such as format examples or constraints. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.
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 ('Delete') and resource ('a task from the task list'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'cancel-task' or explain how deletion differs from cancellation, 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some guidance with 'Use this to clean up old completed tasks,' which implies a context for usage. However, it doesn't specify when NOT to use it (e.g., for active tasks vs. completed ones) or mention alternatives like 'cancel-task' for different scenarios, leaving usage somewhat implied rather than explicit.
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 tool returns status, timestamps, and basic info, but doesn't disclose behavioral traits such as required permissions, error handling (e.g., if taskId is invalid), rate limits, or whether it's a read-only operation (implied by 'Get' but not explicit). This leaves gaps for a tool with no 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences that are front-loaded with the core purpose and return details. Every word earns its place with no redundancy or unnecessary elaboration, making it efficient and easy to parse.
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 low complexity (one parameter, no output schema, no annotations), the description covers the basic purpose and return information adequately. However, it lacks details on behavioral aspects like error cases or permissions, which are important for a status-checking tool in a task management context with multiple sibling tools.
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 100%, with the single parameter 'taskId' documented as 'The task ID'. The description adds no additional meaning beyond this, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the schema handles parameter documentation adequately.
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 'Get' and resource 'current status of a task', specifying what information is returned (status, timestamps, basic info). It distinguishes from siblings like 'get-task-result' (which likely returns task output) and 'get-task-stats' (which likely returns aggregated metrics), though the differentiation isn't explicit.
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 'get-task-result' (for results) or 'list-tasks' (for multiple tasks). The description implies usage for checking a specific task's status but doesn't mention prerequisites, exclusions, 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.
Behavior3/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 of behavioral disclosure. It adds useful context about availability for completed tasks, which isn't obvious from the schema. However, it doesn't describe other behavioral traits like error handling (e.g., what happens if the task isn't completed), response format details, or potential limitations (e.g., size constraints on output).
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 appropriately sized with two concise sentences that front-load the core purpose and follow with a critical usage constraint. Every sentence earns its place by providing essential information without redundancy or unnecessary elaboration, making it efficient and well-structured.
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 (retrieving task results), lack of annotations, and no output schema, the description is somewhat complete but has gaps. It covers the purpose and a key constraint, but doesn't explain the return values (e.g., structure of stdout/stderr) or other behavioral aspects, leaving the agent with incomplete information for reliable use.
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 100%, with the parameter 'taskId' fully documented in the schema as 'The task ID'. The description doesn't add any additional meaning about parameters beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't need to.
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 'Get' and the resource 'full result of a task including stdout/stderr output', making the purpose specific and understandable. It distinguishes from siblings like 'get-task-status' by specifying it retrieves the complete output rather than just status information. However, it doesn't explicitly contrast with all siblings (e.g., 'get-task-stats'), 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context with 'Only available for completed tasks', which helps determine when to use this tool versus alternatives like 'get-task-status' for pending tasks. It doesn't explicitly name alternatives or provide exclusions for other scenarios, but the completion requirement offers practical guidance for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and delivers substantial behavioral context. It discloses key traits: creates non-blocking background tasks, returns task ID immediately, allows up to 3 concurrent tasks by default, and clarifies what it doesn't do (no direct shell execution, no raw stdout/stderr). However, it doesn't mention error handling, retry behavior, or resource constraints beyond concurrency limits.
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 well-structured with clear sections (IMPORTANT warning, What it does, What it does NOT do) and every sentence adds value. It's appropriately sized for a complex tool but could be slightly more concise by integrating some repetitive elements about not being a shell executor. The front-loaded warning is particularly effective.
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?
For a complex tool with no annotations and no output schema, the description provides substantial context about behavior, limitations, and integration with sibling tools. It explains the return value (task ID) and how to use it with other tools. The main gap is lack of information about error responses or what happens when concurrency limits are exceeded, but overall it's quite complete.
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 100%, so the schema already documents all parameters thoroughly. The description doesn't add meaningful parameter semantics beyond what's in the schema - it mentions 'natural language task description' and 'background task' but these are already covered in the schema's task parameter description. The baseline of 3 is appropriate when the schema does the heavy lifting.
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 explicitly states what the tool does: 'Spawns Claude Code (an AI coding agent) as a subprocess to complete development tasks in the background.' It clearly distinguishes from sibling tools by emphasizing it's NOT a direct shell command executor (unlike execute-task) and specifies it creates background tasks that require get-task-status/result for monitoring (unlike list-tasks or get-task-stats). The verb+resource combination is specific and unambiguous.
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 on when to use this tool versus alternatives. It states 'NOT a direct shell command executor' (contrasting with execute-task), specifies it's for 'background tasks' with natural language requests, and directs users to use get-task-status and get-task-result for tracking and retrieval. The 'What it does NOT do' section clearly sets boundaries against misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: that it spawns an AI subprocess, returns conversational responses rather than raw command output, and that Claude Code autonomously decides actions. It could be improved by mentioning potential side effects or limitations, but covers the core behavior well.
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 well-structured with clear sections (IMPORTANT disclaimer, what it does, what it does NOT do, example usage). While slightly verbose, each section serves a clear purpose. The information is front-loaded with the critical disclaimer about not being a direct shell executor. Minor trimming could improve conciseness without losing value.
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?
For a tool with no annotations and no output schema, the description provides substantial context about behavior, limitations, and appropriate usage. It explains the AI agent nature, return format, and key constraints. The main gap is lack of information about the output structure, but given the complexity of the tool, the description does a commendable job of providing necessary context.
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 100%, so the schema already documents all parameters thoroughly. The description adds minimal parameter-specific information beyond what's in the schema - it mentions 'natural language task descriptions' which aligns with the 'task' parameter, but doesn't provide additional semantic context for other parameters. Baseline 3 is appropriate given the comprehensive schema coverage.
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's purpose with specific verbs and resources: 'spawns Claude Code (an AI coding agent) as a subprocess to complete development tasks' and 'accepts natural language task descriptions.' It explicitly distinguishes from sibling tools by contrasting with 'direct shell command executor' and naming the Bash tool as an alternative.
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 on when to use this tool versus alternatives: 'NOT a direct shell command executor' and 'For direct command execution, use the Bash tool instead.' It includes clear examples of appropriate usage scenarios and explicitly states what it does NOT do, helping users choose between this and sibling tools.
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:

[![back-agent-mcp MCP server](https://glama.ai/mcp/servers/ZUENS2020/back-agent-mcp/badges/card.svg)](https://glama.ai/mcp/servers/ZUENS2020/back-agent-mcp)

Score Badge

Copy to your README.md:

[![back-agent-mcp MCP server](https://glama.ai/mcp/servers/ZUENS2020/back-agent-mcp/badges/score.svg)](https://glama.ai/mcp/servers/ZUENS2020/back-agent-mcp)

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/ZUENS2020/back-agent-mcp'

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