Fountain

# Fountain

Use Claude Code, Codex and Gemini CLI from a chat app, with a real computer
behind each conversation. Watch the agent work, steer it, and come back to
the same files.

[Open Conversations](https://fountain-conversations.demo.managoat.com/) ·
[Build with the API](docs/quickstart.md) · [Self-host](docs/self-hosting.md)

## The apps

Choose a chat, a team of agents, or a workbench for a shared project.

| App | What it is | |
|---|---|---|
| [**Conversations**](https://github.com/managoat/demos/tree/main/apps/fountain-conversations) | ChatGPT, except the model has a real computer and you can watch it use one: start a run, follow it turn by turn, steer it, read the raw log. | [Open it](https://fountain-conversations.demo.managoat.com/) |
| [**Team**](https://github.com/managoat/demos/tree/main/apps/fountain-team) | A group chat whose contacts are agents you made, one click each: roster on the left, thread on the right, routines on a schedule. | [Open it](https://fountain-team.demo.managoat.com/) |
| [**Workbench**](https://github.com/managoat/demos/tree/main/apps/fountain-workbench) | Multiplayer engineering: projects over an environment and a vault, work items in them, and teammates you put on a work item by typing. | [Open it](https://fountain-workbench.demo.managoat.com) |

## What runs underneath

**A conversational API to a computer. The machine runs while an agent works
and parks while it waits, so a conversation nobody is talking to burns no
compute.**

Send a prompt to an HTTP endpoint. On the other end a machine wakes up with
your repositories cloned, your packages installed and your credentials already
in the environment, a coding agent runs on it, and the answer comes back.
Between messages the machine parks. A parked machine holds its disk and does
not count against the deployment's sandbox ceiling, so the next prompt lands
on the same files instead of on a fresh box that has to be told everything
again.

Coding agents are not the scarce thing. There are dozens of them and Fountain
runs Claude Code, Codex and Gemini CLI behind one API. The scarce
thing is the computer underneath: building it, installing on it, configuring
it, getting the networking right, getting a credential onto it that the model
never reads, and turning it off before the bill notices. Nobody sets out to
build that, and everybody shipping an agent ends up building it.

Fountain is that half. You write the conversation.

## In one picture

<img src="docs/images/primitives.svg" alt="Three templates, one machine, in three stages. Stage one, write once: Agent, Environment and Vault are rows a tenant writes and reuses. Stage two, at launch: Fountain builds the machine, merges the Environment's secrets with the Vault's and the Vault wins, and starts the agent's runtime. Stage three, the machine: a sandbox receives its environment and runs one or more Conversations, each with its own transcript, on that one machine. The next turn lands on the same machine, an idle machine parks, and the concurrency ceiling reclaims it. Where a deployment runs the egress broker, the real values go to the broker instead, the sandbox gets a placeholder, and the sandbox reaches the internet only through the broker." width="740">

Agent, Environment and Vault are templates: rows you write once and use many
times. A Conversation is a run of an Agent on a machine that Fountain builds,
warms, parks and reclaims. Secrets merge at launch, the Vault winning; on a
deployment with the egress broker on, a bound secret never enters the
sandbox at all. [The four primitives](docs/primitives.md) says why there are
four.

## Self-hosting

[Run your own Fountain instance](docs/self-hosting.md) with the same apps,
API, CLI and SDK under your own keys and infrastructure.

Fountain's own UI is an operator console. You configure things in it; you do
not watch an agent work in it. The three apps we build for that are separate
single-page apps on their own origins, talking to `/api` with a key you paste
in or an OAuth sign-in. Each is static files, so a hosted build works against
your instance as soon as it admits the origin
(`API_CORS_ORIGINS=https://fountain-conversations.demo.managoat.com`).

`CONVERSATIONS_APP_URL` and `TEAM_APP_URL` point the console's own links at
copies you host. [The console, the apps, and the API](docs/concepts/surfaces.md)
says why the line is drawn there.

## Four surfaces

Every public feature lives on the first three; the SDK wraps the verbs most
code actually reaches for.

| Surface | Use it when |
|---|---|
| **Web UI** (`/dashboard`) | Getting started, managing agents, environments, vaults, keys and audit visually |
| **REST API** (`/api/*`) | Scripting, CI/CD pipelines, integrating Fountain into your own tools |
| **CLI** (`fountain`) | Local workflows, manifest-driven `apply`, shell scripting |
| **TypeScript SDK** | Running an agent from your own code: `run(prompt, { agent, vault })` |

The CLI and the SDK are convenience wrappers o

... (truncated)