agentkit-mesh
OfficialClick on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@agentkit-mesh discover agents that help with budget management"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Agents register their capabilities, discover each other by keyword / token-overlap matching, and delegate tasks. Registration and discovery are exposed as standard MCP tools; delegation is performed over HTTP (POST /task) to each agent's registered endpoint.
Quick Start
npx agentkit-meshThis starts an MCP server over stdio, ready to connect to Claude Desktop, OpenClaw, or any MCP client.
Related MCP server: ARCXS Protocol MCP Server
MCP Configuration
Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"agentkit-mesh": {
"command": "npx",
"args": ["agentkit-mesh"]
}
}
}OpenClaw
Add to your OpenClaw config:
mcp:
agentkit-mesh:
command: npx agentkit-meshArchitecture
┌─────────────┐ MCP ┌──────────────────┐
│ AI Agent A │◄────────────►│ │
└─────────────┘ │ agentkit-mesh │
│ │
┌─────────────┐ MCP │ ┌────────────┐ │
│ AI Agent B │◄────────────►│ │ Registry │ │
└─────────────┘ │ │ (SQLite) │ │
│ └────────────┘ │
┌─────────────┐ MCP │ ┌────────────┐ │
│ AI Agent C │◄────────────►│ │ Discovery │ │
└─────────────┘ │ └────────────┘ │
│ ┌────────────┐ │
│ │ Delegation │ │
│ └────────────┘ │
└──────────────────┘MCP Tools
mesh_register
Register an agent with its capabilities.
Parameter | Type | Description |
| string | Unique agent name |
| string | What this agent does |
| string[] | List of capabilities |
| string | Agent's HTTP callback URL — receives |
mesh_discover
Discover agents whose description / capabilities overlap with the query tokens. Matching is plain keyword / token-overlap (no embeddings or semantic search): the query is lowercased and split into tokens, and each agent is scored by the fraction of query tokens found in its description + capabilities.
Parameter | Type | Description |
| string | Search query (e.g. "budget management") |
| number? | Max results to return |
Returns agents ranked by token-overlap score with the matched capability tokens.
mesh_unregister
Remove an agent from the registry.
Parameter | Type | Description |
| string | Agent name to remove |
mesh_delegate
Delegate a task to another agent by name.
Parameter | Type | Description |
| string | Name of the target agent |
| string | Task description to delegate |
| string? | Optional JSON context |
Delegation does not go over MCP. The mesh sends an HTTP POST to the target
agent's registered endpoint (its POST /task URL). Any agent that exposes such
an HTTP endpoint can participate — no MCP server required on the target side.
Agent POST /task contract
The target agent must accept a JSON request body of the form:
{
"delegationId": "uuid",
"task": "Get budget and cost center for Engineering",
"context": { "depth": 1 },
"callbackUrl": "http://mesh-host:8766/v1/delegations/<id>/result"
}(callbackUrl is only present for async delegations.) The agent responds with one of:
Synchronous: HTTP
200and a JSON body{ "result": "..." }(or any JSON; it is returned to the caller as the delegation result).Asynchronous: HTTP
202to accept the task, then laterPOSTthe result tocallbackUrlwith{ "status": "completed" | "failed", "result"?: ..., "error"?: ... }.Failure: any non-2xx status; the body text is surfaced as the error.
If the registered agent has auth configured, the mesh attaches it (e.g.
Authorization: Bearer <token>) to the outgoing request.
Delegating over HTTP directly
The mesh also exposes the delegation flow over its own HTTP control plane:
agentkit-mesh serve --port 8766 # start the HTTP control plane
curl -X POST http://localhost:8766/v1/delegate \
-H "Authorization: Bearer $MESH_TOKEN" \
-H 'Content-Type: application/json' \
-d '{ "targetName": "finance-agent", "task": "Get Engineering budget" }'Securing the control plane
The /v1/* routes (register, discover, delegate, …) require a shared secret.
Configure it with environment variables before starting serve:
Env var | Required | Description |
| yes | Shared secret. Clients must send |
| no | Allowed browser origin for CORS. Defaults to |
/health stays open (no auth) for liveness probes. This is a single shared
bearer secret — there are no per-agent keys, scopes, or rotation.
Use Case: FormBridge
An HR agent filling an expense form discovers the Finance agent:
import { AgentRegistry, DiscoveryEngine } from 'agentkit-mesh';
const registry = new AgentRegistry();
// Agents register themselves
registry.register({
name: 'finance-agent',
description: 'Budget management and expense approval',
capabilities: ['budget', 'cost_center', 'expense_approval'],
endpoint: 'http://localhost:4002/task',
});
// HR agent discovers who can help with budget fields
const discovery = new DiscoveryEngine();
const results = discovery.discover('budget cost center', registry);
// → [{ agent: finance-agent, score: 0.67, matchedCapabilities: ['budget', 'cost', 'center'] }]See examples/ for a runnable demo.
Discovery: keyword / token-overlap matching
Discovery ships as plain keyword / token-overlap matching only — there is no
embedding model or semantic search. DiscoveryEngine.discover() tokenizes the
query, scores each agent by the fraction of query tokens that appear in its
description + capabilities, and returns the matches ranked by that score.
Resource-requirement filtering (scheme/host-aware URI matching) can further
narrow results. That is the full extent of the matching algorithm.
Programmatic API
import { AgentRegistry, DiscoveryEngine, DelegationClient, createServer } from 'agentkit-mesh';All classes are exported for direct use without the MCP server layer.
🤝 Contributing
Contributions are welcome! Fork the repo, make your changes, and open a pull request. For major changes, open an issue first to discuss what you'd like to change.
🧰 AgentKit Ecosystem
Project | Description | |
Observability & audit trail for AI agents | ||
Cross-agent memory and lesson sharing | ||
Human-in-the-loop approval gateway | ||
Agent-human mixed-mode forms | ||
Testing & evaluation framework | ||
agentkit-mesh | Agent discovery & delegation | ⬅️ you are here |
Unified CLI orchestrator | ||
Reactive policy guardrails |
License
MIT © AgentKit AI
Available Tools
4 toolsmesh_delegateA
Delegate a task to an agent. Routes via HTTP callback to the agent's registered endpoint.
Inputs: task (required), targetName (required).
mesh_discoverA
Discover agents matching a query by capability
Inputs: query (required), limit.
mesh_registerA
Register an agent with its capabilities and HTTP callback endpoint
Inputs: name (required), endpoint (required), description (required), capabilities (required).
mesh_unregisterB
Unregister an agent
Inputs: name (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool targets a clearly distinct action in the agent mesh lifecycle: registration, unregistration, discovery, and task delegation. There is no overlap between registration and discovery or between discovery and delegation, so an agent can reliably select the correct tool.
All tools use a consistent mesh_<verb> naming pattern with clear imperative verbs: discover, register, unregister, delegate. The prefix uniformly indicates the server's domain, and there are no mixed conventions or vague names.
Four tools is well-scoped for an agent mesh server: register, unregister, discover, and delegate cover the essential operations without redundancy. Each tool earns its place in the set.
The core lifecycle of registering, discovering, delegating to, and unregistering agents is covered. The only notable gap is the lack of an update/refresh operation, but this can be worked around by unregistering and re-registering an agent.
Maintenance
Related MCP Connectors
AI agent registry — search, discover, register, and connect agents via MCP.
Public MCP for agent verification, work discovery and governed interoperability.
MCP delegation fallback for AI agents to discover capabilities, knowledge, tools, and collaborators.
Discover and call AI agents via MCP. Supports A2A agents and platform agents with async tasks.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that gives AI agents the ability to discover, match with, and build relationships with other autonomous agents. Supports agent registration, matchmaking, messaging, shared goals, relationship lifecycle management, and real-time event subscriptions.45 npmMIT
- AlicenseNot gradedqualityDmaintenanceUniversal agent registry, discovery, and cross-protocol messaging for any MCP-compatible AI agent, enabling registration, discovery, and message translation across six protocols.62 npmMIT
- AlicenseNot gradedqualityDmaintenanceMCP server for agent-to-agent communication -- capability discovery, task delegation, and result aggregation across MCP agents.51 npm1MIT
- AlicenseAqualityCmaintenanceEnables coding agents to discover, message, poll, cancel, and register remote A2A agents via MCP, with an optional read-only local activity dashboard.5MIT