One chat. Every agent.
Any protocol.

Centralize every agent and MCP server in your company — ADK, A2A or custom —
behind one API and one MCP endpoint, with RBAC deciding who can reach what.

Get Started View on GitHub

Protocol-agnostic

Custom REST/SSE, A2A (JSON-RPC) and Google ADK agents — all behind one uniform interface.

AG-UI native

The API emits standard AG-UI events over SSE, so the UI never has to know how an agent is built.

Sessions that persist

Conversation history per agent, stored in Redis and managed by the API. Agents stay stateless.

Multi-agent chats

Talk to several agents in one thread and propagate context between them.

Share & collaborate

Share conversations with revocable links, and build shared multi-agent groups your team uses together.

RBAC for every agent & MCP

Fine-grained, per-agent and per-MCP access control by group or user. One endpoint; each caller only sees what they’re allowed to.

MCP server

Aggregate your agents and company MCP servers into one MCP endpoint for any compatible IDE or CLI — standard OAuth + Dynamic Client Registration, no manual setup.

Built-in observability

Usage, latency and cost dashboards out of the box. Plus a Slack integration.

Deploy anywhere

Published container images, a Docker Compose stack and Helm values for Kubernetes.

How it works

Three steps to one front door for every agent

Register what you already run, put it behind a single gateway, and reach it from anywhere — without each client learning a new protocol.

Register any agent

Point Agentgram at an agent’s endpoint and pick its protocol — Custom REST/SSE, A2A (JSON-RPC) or Google ADK. No redeploy: agents are managed at runtime from the admin panel and stored in PostgreSQL.

One API, one MCP endpoint — behind RBAC

Every agent and every company MCP server is reachable through a single API and a single /mcp endpoint. Role-based access control decides, per agent and per MCP server, exactly who can reach what.

Talk to it from anywhere

Chat from the web UI, call agents as tools from your IDE or CLI over MCP, or wire them into Slack. The API converts every protocol into a uniform stream of AG-UI events.

Architecture

A thin, stateless multiplexer in the middle

Clients speak AG-UI and MCP. Agents speak their own protocol. The Go API translates between them, enforces access, and keeps the sessions.

Clients

Web UI

IDE / CLI · MCP

Slack

AG-UI · MCP →

Agentgram API · Go

JWT auth · OIDC

RBAC per agent & MCP

Protocol mux → AG-UI

Session store

→ native protocol

Agents & tools

Custom REST / SSE

A2A · JSON-RPC

Google ADK

MCP servers

Redis · sessions & pub/sub

PostgreSQL · groups & persistent data

Bring any agent

Different protocols in. One event stream out.

Whatever an agent speaks, the web client always sees the same AG-UI events — so the UI never changes when your agents do.

A plain HTTP endpoint that streams Server-Sent Events (or returns JSON). The simplest way to plug in your own service.

POST /api/agents/{agentId}/chat
Content-Type: application/json

{ "messages": [{ "role": "user", "content": "Hello" }],
"session_id": "optional-uuid" }

Agent-to-Agent over JSON-RPC. Register the endpoint and Agentgram drives the A2A handshake for you.

{ "jsonrpc": "2.0", "method": "message/send",
"params": { "message": { "role": "user",
  "parts": [{ "kind": "text", "text": "Hello" }] } },
"id": "1" }

Google’s Agent Development Kit over REST/SSE. Set the app name and user id; Agentgram maps it to AG-UI.

protocol: adk
endpoint: https://my-adk-agent.internal
adk_app_name: support
adk_user_id: "${user}"

Every protocol above is converted to the same AG-UI event stream the web client consumes.

data: {"type":"RUN_STARTED","threadId":"…","runId":"…"}
data: {"type":"TEXT_MESSAGE_START","messageId":"…","role":"assistant"}
data: {"type":"TEXT_MESSAGE_CONTENT","messageId":"…","delta":"Hello"}
data: {"type":"TOOL_CALL_START","toolCallId":"…","toolName":"SearchTool"}
data: {"type":"TEXT_MESSAGE_END","messageId":"…"}
data: {"type":"RUN_FINISHED","threadId":"…","runId":"…"}

What you can build

One gateway, many workflows

A single integration that each person experiences differently, based on what they're allowed to reach.

🚨

Incident response

Bundle logs, metrics and Kubernetes agents into a shared group and triage an outage together — everyone sees the same thread.

🧰

Agents in your IDE

Add one MCP endpoint to Claude Code or Cursor and call every agent you're allowed to as a tool — ask_logs-agent and more.

📊

Cost & latency in the open

Built-in dashboards break down usage, latency and error rate per agent and per user — no extra observability stack.

🔗

Share a finding

Send a teammate a read-only, time-limited and revocable link to a conversation. They can clone it to keep digging.

🧩

One gateway for the company

Register every agent and MCP server once; RBAC by Google Workspace group or email gives each person only what they're entitled to.

🔌

Bring any framework

Custom REST/SSE, A2A or Google ADK — register the endpoint and it speaks AG-UI like everything else.

See it in action

A real chat client, not a demo widget

Streaming responses, tool calls, multi-agent threads and an admin surface to manage it all.

Chatting with a single agent: streaming markdown answer with a collapsed tool call and a results table. — **Chat with any agent.** Streaming markdown, tool calls and chartable data — whatever protocol the agent speaks.

A multi-agent group thread where one question is routed to both the Logs and Metrics agents. — **Multi-agent groups.** Ask one question, route it across several agents, and keep the context in a single shared thread.

Admin panel listing registered agents with their protocol, status and permissions. — **Manage agents at runtime.** Register agents, pick their protocol and set per-agent permissions — no redeploy.

Observability dashboard with request volume, error rate, p95 latency and requests by resource. — **Observability out of the box.** Requests, error rate, p95 latency and a per-agent breakdown — built in.

Plug it into your tools

Your agents as tools, in any MCP client

Agentgram ships a standard MCP server with OAuth and Dynamic Client Registration — connect with just the URL.

claude mcp add --transport http agentgram https://agentgram.eu/mcp
# then run /mcp, pick "agentgram" and sign in once

You get one ask_<agent-id> tool per agent you can reach, plus the tools of every MCP server registered in Agentgram — all filtered by your permissions.

{
"mcpServers": {
  "agentgram": {
    "type": "http",
    "url": "https://agentgram.eu/mcp"
  }
}
}

On first use the client runs the OAuth flow automatically — discovery + Dynamic Client Registration, no manual setup.

Deploy anywhere

From a laptop to a cluster

Published container images, a Docker Compose stack and Helm values. Database migrations run automatically on startup.

Self-host the whole stack on a single VM.

cd agentgram/examples/docker-compose
cp .env.example .env      # set POSTGRES_PASSWORD, pin AGENTGRAM_VERSION
docker compose up -d      # web on http://localhost:3000

Deploy with the bjw-s app-template chart — plain Kubernetes objects, no CRDs.

helm repo add bjw-s https://bjw-s-labs.github.io/helm-charts
helm install agentgram-api bjw-s/app-template -f values-api.yaml -n agentgram
helm install agentgram-web bjw-s/app-template -f values-web.yaml -n agentgram

One chat. Every agent. Any protocol.

Run the full stack locally in a couple of commands, then point it at your own agents.

Get Started View on GitHub

Open source · MIT licensed · Self-hosted