Allows human-in-the-loop approval gates for irreversible actions via Telegram notifications and inline approval/rejection.
AgentHelm is the control plane that keeps autonomous AI agents safe in production. It wraps any agent framework (LangGraph, CrewAI, custom Python/Node fleets, Claude Code, Cursor) with human-in-the-loop approvals, audit trails, budget guardrails, fail-closed safety, and a shared, versioned Project Brain so agents stay accountable, on-budget, and recoverable.
graph TD
A[Agent Starts Task] --> B[Get Rich Context from Project Brain]
B --> C[Agent Executes Task]
C --> D[Propose New Knowledge/Decisions]
D --> E[Brain Compiler Validates & Resolves Conflicts]
E --> F[Update Project Brain Release]
F --> AGet Context: On startup, an agent fetches versioned, compiled architecture & database context.
Execute Safely: Agent operates within token budgets and Telegram HITL safety guardrails.
Propose Knowledge: As agents discover schemas or make design trade-offs, they propose knowledge entries.
Compile & Evolve: The Brain Compiler verifies evidence, resolves conflicts, and releases the next Project Brain version.
Related MCP server: iranti
Plug AgentHelm directly into Cursor, Claude Code, or Claude Desktop:
.cursor/mcp.json or claude_desktop_config.json{
"mcpServers": {
"agenthelm": {
"command": "npx",
"args": ["-y", "agenthelm-mcp"],
"env": {
"AGENTHELM_CONNECT_KEY": "ahe_live_YOUR_KEY_HERE",
"AGENTHELM_PROJECT": "your-project-name"
}
}
}
}get_context: Query versioned project architecture, database schemas, and conventions.
propose_knowledge: Propose new engineering decisions and codebase discoveries.
get_history: Audit version history logs, diffs, and decision trace blame.
pip install agenthelm-sdkfrom agenthelm import Agent
# Connect to control plane and fetch project brain context
agent = Agent(key="ahe_live_...", name="Architect Agent", project="My App")
# Get context for database schema
context = agent.get_context(category="database")
print("Project Context:", context.entries)
# Propose new knowledge to the Brain Compiler
agent.propose_knowledge(
summary="Migrate authentication from JWT to Session Cookies",
decisions=["Use session IDs mapped to Redis backend"],
files_modified=["lib/auth.ts", "middleware.ts"],
confidence=95
)npm install agenthelm-node-sdkimport { Agent } from 'agenthelm-node-sdk';
const agent = new Agent({
key: 'ahe_live_...',
name: 'Support Bot',
project: 'My App'
});
agent.log('Analyzing sentiment...', 'info');
agent.output({ score: 0.92 }, 'sentiment_results');AgentHelm prevents autonomous catastrophic actions. Mark functions as @irreversible to trigger inline Telegram approval gates:
⚠️ Irreversible Action Requested
Agent:Cloud Architect
Action:destroy_infrastructure
Payload:{"region": "us-east-1"}[ ✅ Approve ] [ ❌ Reject ]
🧠 Brain Compiler: Versioned knowledge engine resolving schema and architectural decision conflicts.
🔭 Fleet Observability: Real-time telemetry, token cost tracking, and execution tracing.
🛡️ Safety Firewall: Classification decorators (@read, @side_effect, @irreversible) with fail-closed default safety.
⏸️ Remote Mission Control: Pause, resume, or override agent state directly from agenthelm.online.
Web Dashboard: https://agenthelm.online
Documentation: agenthelm.online/docs
Issues & Support: GitHub Issues
MIT © AgentHelm Team
Retrieves relevant, ranked context from the Project Brain using semantic context selection. Useful when starting a task, resolving design questions, or looking up project standards.
| Name | Required | Description | Default |
|---|---|---|---|
| task_hint | No | A hint or description of the current task to rank relevance (e.g. 'database migration', 'auth cookies'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must cover behavior. It mentions semantic selection and ranking, but lacks details on limitations, granularity of context, or performance characteristics. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with action, then use cases. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but the description gives enough for a simple retrieval tool. Could mention return format or number of results, but not essential for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a good parameter description. The description adds value by explaining the intent of semantic ranking, which complements the hint parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves ranked context from Project Brain using semantic selection, with specific use cases. It distinguishes from siblings like propose_knowledge and get_history.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly lists when to use (starting a task, resolving design questions, looking up project standards). Does not mention when not to use or alternatives, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieves version history, diffs, blame, or show details for the Project Brain. Allows reviewing exactly who proposed what, what files changed, what conflicts occurred, and when.
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | The entry title (required for 'blame'). | |
| action | Yes | The history action to perform. | |
| version | No | The specific version number (required for 'show'). | |
| category | No | The entry category (required for 'blame'). | |
| version_a | No | The first version number (required for 'diff'). | |
| version_b | No | The second version number (required for 'diff'). |
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 discloses that the tool retrieves history, diffs, blame, and show details, and what information can be reviewed (who, what files, conflicts, when). However, it does not mention any side effects, permission requirements, or constraints beyond the parameter requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two concise, front-loaded sentences. The first sentence specifies the core action and resource, and the second adds valuable detail. No extraneous information or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters, no output schema, and no annotations, the description covers the primary use cases (history, diffs, blame, show) and the type of information available. It lacks details on output format, error handling, or behavior when required parameters are missing, but overall it provides sufficient context for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters have detailed descriptions in the schema. The tool description reiterates general capabilities (e.g., reviewing changes) but does not add new meaning to individual parameters. Baseline 3 is appropriate as the schema already handles parameter semantics adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Retrieves version history, diffs, blame, or show details for the Project Brain.' It uses specific verbs ('retrieves') and resources ('version history'), and lists distinct actions (log, show, diff, blame), effectively distinguishing it from siblings get_context and propose_knowledge.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context on when to use the tool: 'Allows reviewing exactly who proposed what, what files changed, what conflicts occurred, and when.' It implies usage for historical review, but does not explicitly state when not to use it or mention alternatives like get_context for current state.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Submits a Knowledge Proposal containing newly discovered or updated project design, decisions, schema changes, or API specifications. The proposal enters a validation queue before being compiled into the Project Brain.
| Name | Required | Description | Default |
|---|---|---|---|
| summary | Yes | A concise summary explaining what was decided, changed, or discovered. | |
| decisions | No | A list of concrete engineering decisions made. | |
| db_changes | No | Details of any database schema or table changes made. | |
| tests_passed | No | Whether all local tests passed successfully. | |
| apis_affected | No | Details of any API changes made (e.g., endpoints, methods). | |
| files_modified | No | A list of file paths that were modified. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It discloses that the proposal enters a validation queue before being compiled, indicating a delay. However, it omits details about idempotency, permissions, or error handling, leaving gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and resource, and contains no redundant or extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters (1 required), no output schema, and moderate complexity, the description adequately covers the submission process and queueing. It could optionally mention what the agent might expect as a response (e.g., confirmation or ID).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter having a schema description. The tool description does not add additional meaning beyond what the schema provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'submits' and the resource 'Knowledge Proposal', listing specific content types. It distinguishes from sibling tools (get_context, get_history) which are retrieval-oriented.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives like get_context or get_history. The description implies usage for submitting knowledge but does not clarify when not to use it or provide context for choosing among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct operation on the Project Brain: retrieval of context, submission of new knowledge, and querying history. There is no overlap in purpose.
All tool names follow a consistent verb_noun pattern in snake_case (get_context, propose_knowledge, get_history). The repetition of 'get' is acceptable as it indicates retrieval operations.
With only 3 tools, the server is scoped for a focused knowledge management function. While minimal, each tool serves a clear purpose and the count is appropriate for the domain.
The tools cover retrieval, submission, and history, but lack direct update or delete operations for knowledge items. Updates could be handled via new proposals, but that introduces overhead and gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Shared control plane for AI coding agents — tasks, memory, decisions, file locks. 12 tools.
Cross-agent artifact workspace with provenance across Claude Code, Codex, Cursor, LangGraph.
Shared memory for coding agents. Stop re-explaining your codebase every session.
One shared brain for your AI coding agents: team memory, agent Q&A, tasks, and file claims.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jayasukuv11-beep/agenthelm'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
