Condensate is a runtime that runs AI agents on your machine. It runs Claude Code and Codex unmodified, and its own agent, as sessions under one process. For each session it chooses the account that pays, gives the agent placeholder keys instead of real ones, and checks each tool call before it runs.
Apps such as Dex connect to the runtime to show and steer the sessions. The agents need no changes to run under it.
How it works
| Part | Role |
|---|---|
| The runtime | Owns every thread. It writes each thread's events to a log on disk before acting on them, and it starts, resumes and stops the agents. |
| Agents | Claude Code and Codex, unmodified, and Condensate's own agent. Each runs as a session the runtime started. |
| Credential proxy | Holds the real keys. Agents get placeholders, and the proxy adds the real key to outgoing requests, only for the service it belongs to. |
| Policy | Sees each tool call before it runs, and can let it through, block it, or tell the agent to change course. |
| Accounts | Your subscriptions, pooled per workspace. The runtime picks one with usage left for each turn. |
| Apps | Dex, the review hub and the phone app. They read the same log, so they all show the same live threads. |
Durable
Every message and tool call passes through the runtime, so it can keep any agent's work safe across failures without changing the agent.
The runtime writes each message to the thread's log and confirms it before any model runs. The confirmation says the message is stored; the turn's result arrives later in the log. If the account runs out partway, the next turn moves to another account with usage left. If every account is out, the turn waits for the earliest reset and runs again then. If the machine restarts, the runtime reads its log, resumes each agent's session where it stopped, and delivers the messages that were waiting.
| Guarantee | What it means | State |
|---|---|---|
| Nothing is lost | Every message and event is on disk before anything acts on it. | Today |
| Restart and continue | Each agent resumes where its session stopped, and scheduled wake-ups still fire. | Today |
| Keep working when an account runs out | The next turn moves to another account with usage left. | Today |
| Know what was cut off | Each tool call is recorded before it runs, so a crash shows exactly what was in flight. | Next |
| Rerun only what is safe | Tools are marked safe or unsafe to repeat. After a crash, safe ones run again and the agent is told about the rest. | Next |
| Exactly once | A retried message or approval takes effect once. | Next |
| Stop the whole tree | Stopping a lead stops every agent it started. | Next |
The runtime cannot checkpoint inside another agent's model reply. Tool calls are where an interrupted agent changes files or systems, and the policy check runs before each one.
Programmable
Agents can write short programs against the runtime in a sandbox called code mode. Every capability, from starting other agents to the tools of connected services, is a function they can call and combine in one step. Code mode is opt-in today.
A saved workflow keeps a procedure as a program instead of instructions. It runs the same steps every time, saves its place after each one so a crash resumes it, and changes only through review. Any agent can call it by name. Saved workflows are in design.
The runtime's own routines, such as shipping a change or deploying, will also be saved workflows, which lead agents call for the steps while making the decisions themselves.
Consider the following
A developer pays for two Claude plans and a Codex plan. They start a long refactor before bed, and the first plan reaches its limit at 2 a.m. The session stops while the other plans still have usage left. Condensate pools the plans, so the next turn runs on another plan and the refactor continues.
Three agents are working on a laptop when its battery dies. The terminal sessions are gone, and nothing records whether a command was halfway through. The runtime writes each thread to disk before acting on it. After the restart it resumes all three sessions and delivers the messages that were queued.
An agent reads a file with a hidden instruction to send its environment to a stranger. If the environment holds real tokens, they leave with it. Agents under Condensate hold placeholder keys. The real keys stay in the credential proxy, outside the agent's process.
A team starts ten agents on one repository. Two edit the same file, all ten drain one account, and one waits an hour for an answer nobody sees. Each agent gets its own copy of the repository, turns are spread across accounts, and a task waiting on a person appears in Dex and on the phone.
A team writes the rule "every UI change comes with screenshots" into an agent's instructions. When a long session is summarised to save room, the rule can disappear with the rest. Condensate checks every pull request for screenshots, and a saved workflow can run the same steps each time.
A team wants an agent inside its own product. A harness library leaves the agent loop, storage, recovery and interface to them. An agent CLI has no API to build on. Teams can use Claude Code or Codex as the engine and build on the runtime's API, which provides durable threads, live updates, accounts and alerts.
Rules
Agents never hold real keys. The credential proxy is on by default, and the runtime will not start without it. An agent tricked into printing its environment prints placeholders.
The log comes first. Nothing acts on a message until it is on disk, so a restart can continue from the last recorded event.
A policy fault blocks. If the policy check cannot run, the tool call is refused.
Each agent works in its own copy of the repository. Agents running in parallel cannot overwrite each other's files.
A lead never edits code. A lead is an agent that runs a workspace: it starts agents, reads their work, and merges what passes review. Every change arrives as a pull request someone can read later.
Where it stands
| Part | State |
|---|---|
| The runtime, with Claude Code, Codex and its own agent, the log, resume, accounts, the credential proxy, policy and leads | Today |
| Dex, the review hub, and the phone app, installed by hand | Today |
| The SDK and code mode | Early access |
| Recording tool calls, safe reruns, exactly-once messages, stopping the tree | Next |
| Saved workflows | In design |
| More agents, container runners, and running off a single machine | Next |
See Status for access and setup.