TALK TO AGENTS. NOT ENDPOINTS.
Agent Registry + MCP Registry = next-generation API. Authenticate once, talk to any agent. Full state access. A2A communication out of the box.
One Registry. Every Agent.
Start your platform and immediately discover everything. GET /api/v1/agents/registry returns every agent with full A2A-compatible AgentCards. GET /api/v1/mcp/registry lists every MCP server with endpoints. No configuration discovery. No service mesh overhead.
Each agent exposes its capabilities, security requirements, and MCP tool access through standard discovery endpoints. The registry is the source of truth—agents register at startup, clients discover at runtime.
Well-known endpoints (/.well-known/agent-cards) follow the A2A protocol specification. Any A2A-compatible client can discover and connect to your agent mesh without custom integration.
- Agent Registry API — /api/v1/agents/registry returns AgentCards with capabilities, security schemes, and MCP tool extensions.
- MCP Server Registry — /api/v1/mcp/registry lists all MCP servers with endpoints, OAuth requirements, and tool metadata.
- A2A Well-Known Discovery — /.well-known/agent-cards follows the A2A protocol spec. Standard discovery for any compatible client.
Agent-to-Agent. Native.
A2A (Agent-to-Agent) protocol is built in, not bolted on. JSON-RPC 2.0 with methods for message/send, message/stream, tasks/get, and push notifications. Every agent speaks the same language—no translation layers.
Internal agents communicate with external agents seamlessly. Your blog agent can query your analytics agent. Your content agent can delegate to your image generation agent. Mesh topology, not hub-and-spoke.
Streaming responses, task management, and context persistence are protocol-native. Build multi-agent workflows without inventing coordination primitives.
- JSON-RPC 2.0 Protocol — Standard message/send, message/stream, tasks/get methods. No proprietary wire format.
- Bidirectional Communication — Agents call agents. Internal to external, external to internal, or mesh-to-mesh. Same protocol.
- Task Orchestration — Built-in task creation, status polling, cancellation, and push notifications for async workflows.
One Token. Every Agent.
Authenticate once at the mesh edge. Your OAuth2 token grants access to agents based on scopes—no per-agent authentication dance. The mesh enforces permissions uniformly across every agent and every MCP tool.
Security schemes are declared per-agent: OAuth2 with PKCE, API keys, or custom schemes. The registry advertises requirements; clients negotiate at connection time. AgentCards include full security scheme definitions.
Multi-tenant isolation is automatic. User A's token only accesses User A's agent contexts. Same mesh, complete separation. Audit trails capture every authenticated interaction.
- Mesh-Wide OAuth2 — Single authentication grants scoped access across all agents and MCP tools. No re-authentication.
- Per-Agent Security Schemes — Each agent declares its requirements: OAuth2, API key, or custom. Clients negotiate automatically.
- Multi-Tenant Isolation — Token scopes enforce tenant boundaries. User A never sees User B's agent contexts.
Agents Own the Domain.
Unlike traditional APIs that expose narrow endpoints, agents have full access to state and the systemprompt domain. File storage, content management, user data, analytics—agents query and mutate the complete platform state.
MCP tools are first-class: database, files, content, users. Agents don't call REST endpoints—they invoke tools with rich type safety and automatic permission enforcement.
This is the "next generation API": instead of crafting request/response pairs, clients send natural language to agents who understand the full context and have the tools to act on it.
- Full Platform Access — Agents access files, content, users, analytics, and configuration. Not narrow REST slices.
- MCP Tool Integration — Rich tool interface with type safety and permission enforcement. Richer than REST, safer than raw SQL.
- Natural Language Interface — Clients send intent. Agents understand context and execute. The API is conversation.
Works With Everything.
Claude Code, Claude Desktop, ChatGPT, any MCP client—they all connect to your mesh. HTTP-native transports (streamable-http) work with modern MCP implementations. Point and connect.
External AI providers become first-class mesh participants. Claude Code authenticates, discovers your agents via the registry, and starts sending A2A messages. Same protocol internal agents use.
Your mesh is your API. External integrations query agents instead of building bespoke REST clients. The AI handles the interface—you provide the domain and tools.
- MCP Client Compatible — Claude Code, Claude Desktop, ChatGPT—any MCP client connects over standard HTTP transport.
- External AI Integration — AI providers become mesh participants. They authenticate, discover, and communicate via A2A.
- Your Mesh = Your API — No separate REST API to maintain. Agents ARE the API. AI handles the interface complexity.
