Integrations

Your tools start the agent. Managoat runs the machine.

Connect your editor, chat app or code to a coding agent on a ready sandbox. Managoat provisions the machine, preserves its work between messages and parks it when the agent stops.

Start from what you have.

Choose the starting point that matches your stack. Each example works against an instance you run yourself.

You have

A React app

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

How The TypeScript SDK and a user-scoped token from Sign in with Fountain. Your component starts the run and renders the stream itself.

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

const fountain = new Fountain({ apiKey: userToken }); // from Sign in with Fountain
const run = fountain.runRequest({ agent_id: agentId, prompt });
for await (const chunk of run.textStream) setReply((text) => text + chunk);
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 backend or a script

You want Start an agent and follow its work, with nothing installed.

How Two requests: create the conversation with a prompt, then read its event stream.

curl -sS -X POST https://managoat.com/api/conversations \
  -H "Authorization: Bearer ftn_..." -H "Content-Type: application/json" \
  -d '{"agent_id": "<agent_id>", "prompt": "Review the open PRs."}'

curl -N -H "Authorization: Bearer ftn_..." \
  "https://managoat.com/api/conversations/<id>/stream?blocks=true"
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 managoat/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 "@managoat/fountain-sdk";

const fountain = new Fountain({ apiKey: token }); // from the OAuth flow
const roster = await fountain.agents.list();
const run = fountain.resume(conversationId).send("Pick up where you left off.");
for await (const event of run) render(event);
Read the guide →

Connect to the same agent from an editor or from code.

Whether a prompt starts in an editor, a chat app or your code, Managoat runs the agent in its sandbox. The machine parks between messages and wakes with its files and work intact.

ACP

Agent Client Protocol
fountain acp --agent <name>

Run a Fountain agent from an ACP-capable editor or chat app. The CLI connects the client to a remote sandbox, so you can close your laptop mid-turn and pick up the result when you return. The protocol's block vocabulary passes through without another adapter.

An editor or chat app launches the local CLI; the work runs remotely.

Editors over ACP →

Works with

  • 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

REST, SSE and webhooks

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

Start and follow agents from your own code. Create a Conversation, send a prompt, stream the parsed blocks or receive a signed webhook when the turn ends. Sign in with Fountain gives browser apps an OAuth flow. The apps this project ships use the same public API and SDKs.

Your code drives everything the console can, and more.

The API reference →

Works with

  • 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 · @managoat/fountain-sdk on npm
  • Python · fountain-agent-sdk on PyPI
  • 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

Managoat no longer serves the OpenAI-compatible API or AG-UI. Changing a base URL does not move a client that used them. Each page says what to build on instead, and how to keep a thread you already have.

Give the agent the tools it needs.

MCP servers and service credentials stay separate from the client that started the run.

MCP

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

Give each Fountain agent the stdio or HTTP MCP servers it needs. Fountain passes their declarations to the runtime without curating them. With a brokered Gmail Connection, the sandbox gets inbox tools without receiving the OAuth token. Fountain also serves MCP tools of its own, listed below.

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

The MCP servers Fountain hosts →

Connects to

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

Keep service credentials out of the sandbox.

On hosted accounts with the egress broker enabled, Managoat replaces each bound credential with a placeholder inside the sandbox and attaches the real value only to matching outbound requests. Use a preset below or add a custom binding.

  • 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)

Choose what runs behind the integration.

Pick the coding agent, model access and sandbox separately. The client-facing interfaces stay the same.

Runtimes

Choose the coding agent the sandbox runs. Every client-facing interface sees the same shape.

  • Claude Code
  • Codex
  • Gemini CLI
  • OpenCode

Model access

Bring your own credentials. Your model provider bills you directly; Fountain never marks up tokens.

  • 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

Put the agent on a Nostr relay.

Buzz runs in the other direction. Managoat hosts the agent and brings its identity to the relay.

Nostr

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

Run a Buzz identity on Fountain instead of your laptop. It holds presence on the relay, answers a mention from its sandbox and keeps its signing key on the server.

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

Buzz on Fountain →

Shows up in

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

Haven't found your tool?

If it launches an ACP agent, it can connect directly. Otherwise, build against Managoat's REST API or an SDK.

Names and marks belong to their owners. "Verified" means we tested the integration end to end; other compatibility is based on each project's protocol documentation.