The command-line tool
The forge command is a single small program. It does three things: signs you in, lets you look at sessions that are running in the cloud, and keeps your machine and the cloud in step. Alongside it, forge-hook plugs into Claude Code so every turn you take locally is saved to the cloud without you doing anything.
| |
What happens on each turn
When you work locally, Forge records two moments: when a turn starts, and when it finishes. At the finish it packages up what happened — the conversation, which model answered, what it cost — and stores it in the cloud as a point you can return to.
If the network is down, none of that is lost. The records wait on disk and are sent when you reconnect, with the retries spacing themselves further apart each time rather than hammering a service that is down. If a backlog builds up beyond a handful of entries, the tool warns you — in practice that usually means something is misconfigured, not that you have genuinely been offline that long.
Run it anywhere
Forge’s runtime has no opinion about where it runs. Any machine that can reach your Git remotes and your AI providers will do: a laptop, a home server, a cheap cloud instance, a Kubernetes cluster, or GitHub Actions.
Your own machine or any server — the simplest option. Run it as an ordinary process on Linux or macOS. No containers, no orchestration.
GitHub Actions — the natural fit for “work on this repository, on this branch”. A workflow checks out the code, picks up the conversation so far, runs the agent, commits the result and reports back. You can start it from the command line or from the “continue in cloud” button in the browser.
Kubernetes — the fit for running many agents at once, and for long multi-step work. Pools of machines can be restricted to a particular AI provider, or reserved so that a long run keeps the same machine.
All three keep the same session format and the same sync behaviour. Moving between them is a setting, not a rebuild.
Sessions that stick
By default each turn goes to whichever machine is free — cheap, and fine for short work.
For multi-step runs you can ask for the opposite: turns after the first stay on the machine that handled the first one, until it has been idle for half an hour. That keeps a long piece of work on a machine that already has the repository checked out and warm. When the machine goes away, the history does not — it lives in the sessions service, not on the machine.
The handoff, both ways
The handoff is symmetric. Start in one place, switch, come back. Everything stored — the conversation, the saved points, the branch, the transcript — survives the round trip.
Limits you set
Every cloud turn is metered: what it used, what it cost, which provider answered, how long it took. Your organisation can set limits on spend and volume, and they are checked before a turn is sent rather than after the bill arrives. Current usage against those limits is visible in the console.
What you get
Everything below is live in production today.
- Sign-in and credential storage on your machine
- Looking at and continuing cloud sessions from the command line
- Sync in both directions
- Automatic recording of local Claude Code turns, with an offline backlog that catches up
- A GitHub Actions option and a Kubernetes option
- Per-organisation limits, both measured and enforced
Where your local files live
Everything the tool keeps on your machine sits in one folder — your organisation and preferences, your credentials (readable only by you), and any records still waiting to be sent. It is plain text: easy to look at, easy to back up, and easy to remove entirely if you want to start clean with forge unlink.
Try it
The forge command is a single binary with nothing else to install — the same pattern as sc
. Once it is on your PATH:
| |