Agent on the glass
Build the engineering workbench.
Show the thread, shell, diff and event stream. Let people steer the work while it happens.
Open source · self-hosted · AGPL-3.0-or-later
Send a prompt. A sandbox wakes up with the repos, tools and credentials it needs, an agent gets to work, and the answer streams back. Build an engineering workbench around it, hide it behind your product, or make something we have not imagined yet.
Fountain is the open-source conversational API underneath. Run it on your infrastructure, keep the data in your database, hold the keys, and change anything.
Your server · your database · your keys · your agents
Fountain
one conversational API
Sandbox
repo · tools · config · credentials
Running agent
fixing test_user_login.py …
live
Keep it on the screen while engineers steer every move. Put it behind a file upload, a button or an API and return only the result. Let a webhook wake it up when nobody is watching.
These look like different products to the customer. Underneath, they all need the same thing: a machine that can pick up a conversation and keep working after you close your laptop.
Agent on the glass
Show the thread, shell, diff and event stream. Let people steer the work while it happens.
Agent behind the interface
Your customer asks for a brief, a chart or a change. Your product returns it. The agent stays plumbing.
Agent off on its own
A webhook, cron job, CI run or another agent can start a conversation and follow it to the result.
The reusable pieces
Fountain keeps the machine, credentials, agent configuration and live work separate. Change one without rebuilding the rest, then reuse the same setup anywhere your product needs it.
The machine: repositories, packages, env vars and setup scripts.
The credentials a run is allowed to use, kept apart so rotating a token is not a machine edit.
The runtime, model, skills and tools, under one name your software can call.
The running work: prompts, streamed output and the sandbox behind them.
Your first agent
Describe the machine once. Repositories, packages, env vars and setup scripts. The Environment is reusable across agents and runs.
import { Fountain } from "@agentshit/fountain-sdk";
const fountain = new Fountain(); // FOUNTAIN_API_KEY
const environment = await fountain.environments.create({
name: "app",
repositories: [{
url: "https://github.com/acme/app",
mount_path: "/work/app",
}],
setup_script: "cd /work/app && npm install",
});
Add credentials only when a run needs them. A Vault is an optional set of environment-variable overrides. Write its values separately, then attach it only to runs that need them.
const vault = await fountain.vaults.create({ name: "ci-bot" });
await fountain.vaults.secrets.set(
vault.id,
"GITHUB_TOKEN",
process.env.GITHUB_TOKEN!
);
Name the agent and its tools. Pick the runtime and model, add skills and MCP tools, attach the Environment, and allow the Vault callers may opt into.
await fountain.agents.create({
name: "reviewer",
runtime: "claude",
model: "anthropic/claude-sonnet-5",
environment_id: environment.id,
allowed_vault_ids: [vault.id],
skills: [{ source: "obra/superpowers", ref: "v2.1.0" }],
mcp_servers: {
deepwiki: {
type: "http",
url: "https://mcp.deepwiki.com/mcp",
},
},
});
Send a prompt. Attach the Vault when this run needs its GitHub token; leave it off otherwise. Fountain streams the work as it happens and keeps the conversation ready for the next prompt.
import { Fountain } from "@agentshit/fountain-sdk";
const fountain = new Fountain(); // FOUNTAIN_API_KEY
const run = await fountain.run(
"Fix the failing test and open a PR",
{ agent: "reviewer", vault: "ci-bot", channelId: ticket.id }
);
console.log(run.text);
Interfaces
Use Fountain’s API and SDK in your product. Speak OpenAI-compatible chat from existing tools. Plug into editors over ACP or build a live interface over AG-UI. Every door reaches the same agents, conversations and event stream.
An AG-UI host starts and follows a Fountain agent.
An editor or chat app launches the local CLI; the work runs remotely.
Any client or gateway with a base-URL field drives a Fountain agent.
Your code drives everything the console can, and more.
Choose the coding agent the sandbox runs. Every client-facing interface sees the same shape.
Bring your own credentials. Your model provider bills you directly; Fountain never marks up tokens.
Where the agent runs. A hosted provider, or a runner on hardware you own that dials out over WebSocket.
Tools and systems
Attach any stdio or HTTP MCP server. Use built-in credential bindings to keep provider tokens out of the sandbox.
Own the data
Prompts, events, configuration and the audit trail land in your Postgres. Logs stay on stdout. Metrics stay on a private listener. Trace and error export turn on only when you configure a destination.
Metrics
Local by defaultScrape routes, database timings, provisioning, turn latency and sandbox state from the private metrics listener. The repo includes dashboards and alerts.
METRICS_PORT=9568
Traces
Off until configuredExport request, provisioning and turn spans over OTLP. Point the standard exporter variables at Honeycomb, Grafana Tempo or another compatible collector.
OTEL_EXPORTER_OTLP_ENDPOINT=…
Errors
Off until configuredSend grouped crashes without cookies, IP addresses or request bodies. Unset the DSN and the SDK stays inert; nothing is buffered for later.
SENTRY_DSN=…
Health
/health
reports liveness. /health/ready
reports whether the instance can receive traffic.
Own the stack
Begin with Docker Compose and the published release image. If the workload grows, run a clustered set of replicas against the same Postgres. The deployment shape changes; the API does not.
Or run the OCI image anywhere that can keep a Phoenix process and Postgres alive. Compare deployment requirements →
Make it yours
Host the apps and API yourself. Keep conversations and configuration in your Postgres. Hold the encryption keys. Run sandboxes through Sprites, E2B, Daytona or machines on your own network. The engine and apps are open for you to take apart and reshape.