Integrations

It speaks what your stack already speaks.

Managoat answers AG-UI, the Agent Client Protocol, OpenAI chat completions and MCP, on top of its own REST API. So the editor, the chat app, the gateway or the framework you use today can hire an agent on a sandbox with a URL and a key, and nothing to install on our side.

Six ways in, one agent behind them.

Each protocol is a translation of the same conversation. Whichever door a prompt comes through, the agent runs on a sandbox that parks between messages and wakes with its work intact.

AG-UI

Agent-User Interaction Protocol
POST /api/agui/:agent_id

The open protocol between an agent and a front end, from CopilotKit. Fountain answers a RunAgentInput with the standard event stream, so a Fountain agent takes a seat next to a LangGraph or CrewAI one with no adapter. Pass the host's tools and a call comes back as TOOL_CALL events. One thread binds to one conversation, and the sandbox is the memory.

An AG-UI host drives a Fountain agent.

OpenBot and AG-UI →

Speaks it

  • OpenBot · CopilotKit's agent platform; a coworker per agent, verified
  • CopilotKit · React, Angular and React Native apps, via HttpAgent
  • Slack · CopilotKit's chat-platform clients
  • LangGraph · a peer in the same roster
  • CrewAI · a peer in the same roster
  • Mastra · a peer in the same roster
  • Pydantic AI · a peer in the same roster
  • Google ADK · a peer in the same roster

ACP

Agent Client Protocol
fountain acp --agent <name>

Zed's editor protocol for coding agents. Fountain is an ACP client of the agents it runs in sandboxes and an ACP agent for the editor in front of you, so the same block vocabulary flows through untranslated. Close the laptop mid-turn; the turn continues on the sandbox and replays when you reopen.

An editor or chat harness spawns the CLI and drives a conversation.

Editors over ACP →

Speaks it

  • Zed · an agent_servers entry, verified
  • JetBrains IDEs · AI Assistant's acp.json, no subscription needed
  • Neovim · CodeCompanion, avante
  • Emacs · agent-shell
  • VS Code · the ACP client extensions
  • Obsidian · the Agent Client plugins
  • Jupyter · agent-client-kernel
  • OpenClaw · its acpx plugin, verified, from Telegram, Discord, Slack, Signal or iMessage
  • Discord · the community ACP bridges, and Telegram's
  • Vercel AI SDK · the community acp-ai-provider, an ACP agent as a LanguageModel

OpenAI-compatible

Chat completions, where the model is an agent
POST /v1/chat/completions

The request shape every gateway and every chat client already speaks. Point one at your instance with an API key, and GET /v1/models fills its picker with your agents. Your tools come back as tool_calls, so a Fountain agent sits inside a LangChain loop or a Deep Agents plan as a subagent. A thread key binds each chat to one sandbox. Alpha, behind a flag; ask and it is on.

Any client or gateway with a base-URL field drives a Fountain agent.

The OpenAI-compatible API →

Speaks it

  • Open WebUI · a base URL and a key
  • LibreChat · a custom endpoint
  • LiteLLM · a route, verified against the example in the repo
  • Portkey · a gateway route
  • Kong AI Gateway · a gateway route
  • Cloudflare AI Gateway · a gateway route
  • OpenAI SDKs · base_url, in any language
  • Vercel AI SDK · createOpenAICompatible
  • LangChain · as a model, a tool, or a Deep Agents subagent
  • LangGraph · one thread_id is one sandbox per agent
  • Continue · apiBase on an openai provider
  • Cline · its OpenAI Compatible provider
  • Aider · OPENAI_API_BASE
  • Dify · the OpenAI-API-compatible plugin
  • Raycast · a custom provider
  • curl · one request

MCP

Model Context Protocol, both ways
Any MCP server, on any agent

An agent's config lists the MCP servers it may call, and Fountain passes the declaration through and curates nothing. A Gmail Connection holds the OAuth grant on the server, so an inbox arrives as tools with no token in the prompt. Fountain also serves MCP to its own sandboxes: a teammate to message, an email address and a phone number, a Buzz channel, a mailbox.

Agents call the servers you name; Fountain hosts four of its own.

The MCP servers Fountain hosts →

Speaks it

  • Gmail · a Connection, then the inbox as seven tools
  • fountain-team · message a teammate, from inside the sandbox
  • fountain-comms · a teammate's own email and phone
  • fountain-buzz · post to a Buzz channel as the agent
  • Any stdio or HTTP server · named on the agent, run in its sandbox

REST, SSE and webhooks

Fountain's own API
/api, with a TypeScript SDK and a CLI

Everything above is a translation of this. Create a conversation, send a prompt, stream the turn as blocks the server has already parsed, or take a signed webhook when it ends. Sign in with Fountain gives a browser app of your own an OAuth flow whose tokens are ordinary API keys. The three apps this project ships are built on exactly this and nothing private: static files, the SDK, your key.

Your code drives everything the console can, and more.

The API reference →

Speaks it

  • Conversations · the chat app we ship, static files on the SDK
  • Team · the team messenger, on the same public API
  • Workbench · the shared engineering workbench
  • TypeScript · @agentshit/fountain-sdk on npm
  • Go · the fountain CLI, and its source
  • GitHub Actions · a webhook, or the CLI in a step
  • React · a static app on Sign in with Fountain
  • Claude Code · the /skill file teaches it the API
  • Cursor · the same skill, and /llms.txt
  • Hermes Agent · the plugin this repo ships: fountain_run and six more
  • curl · everything the SDK does

Nostr

Buzz, the other direction
POST /api/buzz/agents

Buzz is an agent workspace on Nostr, and on the desktop an agent's body runs on your laptop. Bind its identity to a Fountain agent instead and the body runs here: it holds presence on the relay, answers a mention from a sandbox, and its key stays in a vault Fountain signs with.

Outbound. Fountain hosts the agent and shows up on the relay.

Buzz on Fountain →

Speaks it

  • Buzz · provision from the desktop, or the API
  • Nostr relays · group channels, presence, mentions

Start from what you have.

Six shapes of builder, and the few lines each one needs. Every snippet runs against the hosted instance or your own.

You have

A React app

You want An agent in the product, with a sandbox of its own behind the chat.

How Point CopilotKit's AG-UI client at the agent's endpoint. No adapter, no proxy.

import { HttpAgent } from "@ag-ui/client";

const reviewer = new HttpAgent({
  url: "https://managoat.com/api/agui/<agent_id>",
  headers: { Authorization: "Bearer ftn_..." },
});
Read the guide →

You have

An editor

You want A thread in Zed that runs on a machine that is not yours.

How One agent_servers entry. Credentials come from fountain auth login.

"agent_servers": {
  "Fountain: reviewer": {
    "command": "fountain",
    "args": ["acp", "--agent", "reviewer", "--permission", "ask"]
  }
}
Read the guide →

You have

A chat UI with a base-URL field

You want Your agents in its model picker.

How Base URL, key, and a thread header so each chat keeps one sandbox.

curl https://managoat.com/v1/chat/completions \
  -H "Authorization: Bearer ftn_..." \
  -H "X-Fountain-Thread: prs-2026-08-25" \
  -d '{"model": "reviewer", "stream": true,
       "messages": [{"role": "user", "content": "Review the open PRs."}]}'
Read the guide →

You have

A personal assistant

You want OpenClaw or Hermes hands a task to a Fountain agent from Telegram, Discord or Slack.

How OpenClaw's acpx plugin spawns fountain acp. Hermes installs the plugin this repo ships.

# OpenClaw: an ACP backend
openclaw plugins install @openclaw/acpx

# Hermes Agent: fountain_run and six siblings
hermes plugins install BinaryBourbon/fountain/integrations/hermes/fountain --enable
Read the guide →

You have

A pipeline

You want Start a run from CI, hear about it when it ends.

How The CLI in a step, a signed webhook to a URL you own.

fountain run reviewer --prompt "Review PR #$PR"

fountain webhooks create https://example.com/hooks/fountain \
  --event conversation.turn.done --event conversation.turn.failed
Read the guide →

You have

Your own product

You want A roster of agents and threads, under your login, on your origin.

How The SDK for the calls, Sign in with Fountain for the user, one static app.

import { Fountain } from "@agentshit/fountain-sdk";

const fountain = new Fountain({ apiKey: token }); // from the OAuth flow
const conv = await fountain.conversations.create({ agent: "reviewer" });
for await (const block of fountain.conversations.stream(conv.id)) render(block);
Read the guide →

What runs behind the door.

The agent, its model, its machine, and the people it talks to. Pick each one; none of them changes the protocols above.

Runtimes

The coding agent the sandbox runs. All four speak ACP to Fountain, so every surface above sees one shape.

  • Claude Code
  • Codex
  • Gemini CLI
  • OpenCode

Models

Bring your own key. Inference bills your account; Fountain never marks up a token.

  • Anthropic
  • OpenAI
  • Google Gemini
  • Claude subscription

Sandboxes

Where the agent runs. A hosted provider, or a runner on hardware you own that dials out over WebSocket.

  • Sprites
  • E2B
  • Daytona
  • Your own machine

Chat surfaces

Where a person talks to the agent, through OpenClaw or Hermes on one side or a Buzz channel on the other.

  • Telegram
  • Discord
  • Slack
  • Signal

Credentials the agent uses and never holds.

The egress broker attaches a real credential to a request on its way out, so the sandbox, the prompt and the transcript see a placeholder. A preset for each of these, and a custom binding for anything else.

  • Anthropic
  • Cloudflare
  • Cohere
  • Datadog
  • DeepSeek
  • Discord
  • Fireworks AI
  • Google Gemini
  • GitHub
  • GitLab
  • Groq
  • Linear
  • Mistral AI
  • Notion
  • NPM
  • Github NPM registry
  • OpenAI
  • OpenRouter
  • PagerDuty
  • Perplexity
  • Postmark
  • Resend
  • SendGrid
  • Sentry
  • Shopify
  • Slack
  • Stripe
  • Supabase
  • Telegram
  • Together AI
  • Vercel
  • xAI (Grok)

Something of yours not on the list?

If it takes a base URL, spawns a command, or renders AG-UI, it already works. If it does neither, the REST API is the whole product and the SDK is one import away.

Product names and marks belong to their owners and name what the protocol reaches; none of them endorses Managoat. Marked "verified" where we ran it end to end; the rest speak the protocol by their own documentation.