Skip to content

Protocols Preview

Connect agents, editors and tools in the protocols they already speak.

An editor talking to an agent, an agent delegating work and an agent calling a tool are different conversations. TrogonAI provides adapters for each, with NATS carrying messages between services.

Adapters are built; support has explicit limits

The protocol bridges exist in the repository. Supported methods, security boundaries and remaining integration gaps are documented in the protocol support reference. A bridge does not supply the agent or tool service behind it.

The right protocol for the job ​

Follow an agent's conversations with its client, another agent and its tools. Select a protocol to see what travels in each direction.

Follow a connection
Request Response
Editor or clientWhere you workPrompts · Permissions
Your agentWhere the work happens Connected through TrogonAI
Another agentDelegate and collaborateTasks · Progress · Artifacts
Tools & resourcesUse an MCP serverTools · Context · Prompts
ACPA2AMCP
Follow the work through its conversations
CallerRequestAgent or server

A client prompts an agent. The agent can delegate work or call a tool.

CallerResponseAgent or server

Session updates, task results and tool output return through their own protocols.

Each pair of arrows is a conversation carried over NATS by its protocol adapters. The agent application decides when to delegate work or use a tool. Callbacks and notifications follow their protocol's lifecycle.
  • A2A
    Agent2Agent
    AgentAgent

    Send work to another agent and follow its task updates.

    HTTP, stdio and NATSExplore A2A
  • ACP
    Agent Client Protocol
    Editor or clientAgent

    Prompt an agent, review its work and answer permission requests.

    Stdio, HTTP, WebSocket and NATSExplore ACP
  • MCP
    Model Context Protocol
    AI applicationTools and context

    Discover and call tools, read resources and retrieve prompts.

    Stdio, Streamable HTTP and NATSExplore MCP

A2A: agent-to-agent work ​

Use A2A when another agent should take on work and report what happens. The adapters carry messages, task queries, cancellation and streamed updates. Agent cards describe an agent's capabilities; push notifications provide another way to follow its work.

The policy gateway checks calls routed through gateway ingress. The local HTTP adapter sends calls directly to agents unless gateway routing is enabled. A separate edge, a2a-bridge, obtains caller-scoped NATS credentials before forwarding. Its default enforce mode requires caller proof of possession; development-only shadow and off modes relax that enforcement.

The bridge serves plain HTTP and needs an external TLS terminator for public HTTPS. No TLS-terminating bridge deployment is defined in this repository. The local HTTP adapter and the bridge are distinct entry points, so choose and configure the boundary appropriate to your deployment.

A2A support and boundaries

ACP: an agent in your editor ​

Use ACP when an editor or another client needs an interactive agent. Prompts, updates, file access, terminal callbacks and permission requests cross the bridge while the agent runs behind NATS.

Local clients can launch the stdio bridge. Remote clients can use the HTTP and WebSocket listener. Support follows the pinned SDK and its schema, with known gaps tracked in the ACP conformance matrix. Native MCP-over-ACP messages and connection-scoped authentication push updates are not routed today.

ACP support and boundaries

MCP: tools and context ​

Use MCP when an AI application needs to call a tool, read a resource or retrieve a prompt. The NATS adapter supports the client and server roles; stdio and Streamable HTTP bridges connect existing clients to a backend server.

Tool behavior and available capabilities come from that backend. The transport does not create a managed tool registry, authorize individual tools or provide OAuth custody. The remote MCP and ACP listeners still need the caller-identity work described in their draft proposal before they can serve that security role.

MCP support and boundaries

How the pieces fit ​

  • Pick the right conversationA2A carries agent work, ACP connects a client to an agent and MCP exposes tools and context.
  • Keep services connectedProtocol adapters carry traffic over the NATS backbone while clients use a local or remote transport.
  • Keep responsibilities clearA bridge carries messages. Agent execution, tool implementation and authorization have their own owners.

Where it stands ​

  • A2A messaging and task updatesNATS client and server adapters, HTTP and stdio surfaces, task streaming and push notification support.Built
  • A2A policy and authenticated edgeGateway ingress enforcement and a separate HTTP edge with default-enforced caller proof and caller-scoped NATS credentials. Public HTTPS needs external TLS termination.Built
  • ACP editor and remote connectionsA stdio bridge and an official SDK-backed HTTP and WebSocket listener connect clients to NATS-backed agents.Built
  • MCP tools, resources and promptsNATS transports for both protocol roles, plus stdio and Streamable HTTP bridges.Built
  • Verified callers at MCP and ACP remote edgesThe caller-identity proposal remains draft. MCP Host checks and ACP Origin checks do not authenticate the caller.Designed

Learn more ​

Released under the Apache License 2.0.