Anvil

Features

Anvil is the environment agents and people write code in and the forge the code lives in. These are its parts, in the order a piece of work goes through them.

Agents and threads

Threads
A thread is an agent at work on one thing: Claude Code, Codex, Copilot CLI, or any agent an extension brings. You read it as it goes, a conversation with every command it ran and every file it changed, and you can write into it at any point.
Real terminals
Threads run in real terminals, the same ones you use: Ghostty's VT core, drawn cell by cell. Agents run your tests, your dev server and your build the way you would.
What it needs, beside it
A thread opens what its work needs next to its conversation: a preview of the running app, a terminal, a file, the diff of what it changed, a profiler, a pane an extension draws.
Asks
When an agent needs a decision it asks once, with the answers it sees, and goes on with other work. Your answer reaches it as a message. A permission it needs can be allowed, denied, or denied with a note saying what to do instead.
Leads
Every project has a Lead: a thread that knows the project, reads its issues and its other threads, and starts new threads for real work instead of changing files itself. Over all of them, the orchestrator answers what's going on anywhere.
They keep running
Threads run in a process of their own on their machine, so closing Anvil, restarting it or updating it doesn't stop a turn. Each comes back where it was.

Repositories

Hosting
A repository lives on a node you run: a laptop for your own work, a server for the team's. It mirrors to any git remote you add, so the rest of the world sees it where it already looks.
Code, commits and branches
Every repository's files, history and branches, read from git, with the README drawn under its folder and each file as it is on the branch you pick.
A branch per thread
Each thread works on a branch of its own in a worktree of its own, so any number of them share a repository without stepping on each other, or on you.
Documents
A project's design notes, decisions and plans sit beside its code, versioned with it, and agents read them before they start.
$ anvil clone team/harbor
cloned into ~/code/harbor
forge.team · 3 open changes · 12 issues
Cloning from the team's forge.

Issues

From anywhere
Issues are filed by people, from a review comment that's bigger than its change, from a check that keeps failing, or by a user from inside the app you ship, with a screenshot and what they were doing.
Triage
The Lead reads each new issue, finds what it's about in the code, asks what it can't tell, labels it, and says whether it would start a thread on it.
An issue becomes a thread
Start a thread on an issue, or let the Lead do it, and the issue is its brief. The issue shows the thread's progress, its change and its checks from then on.
Tasks
Larger work is a task with the issues and changes under it; a Lead can split a task across several threads and keep them in step.

Changes and review

Opened by the work
When a thread finishes, its branch opens as a change, linked to the issue it came from and carrying the conversation that made it.
Proof
Every change says what's now true and shows it: screenshots of the running app, before and after, the checks that ran on which machines, the size of the diff, and a link to try it.
Review, both ways
People review agents' changes and agents review people's. A comment on a line goes to whoever wrote it; an agent answers with a commit and a reply.
Merging
Approved and green, a change lands in order with the others waiting. If main moved under it, the thread that made it rebases it and runs its checks again.
ML
Mara Lind

Why a new client here instead of the shared one?

R
Retry uploads

The shared one sets a 2 s timeout; uploads need longer. Moved the timeout into an option instead. a71f3c0

A question in review, answered from the thread's own work.

Checks

Defined with the code
A project's checks are commands in its config, with the platforms they run on. The same commands run on your machine before you push.
On your machines
Checks run on the machines you've added, each on a platform it ships to, beside the threads. Nothing waits for a hosted runner.
Failures go home
A failing check's log goes to the thread whose commit broke it, which fixes it on its branch and runs it again. For a person's change, the failure comes to them, with a thread offered to look into it.
Readable
Every check's log, timing and machine is kept with the change, so a flaky test is easy to see across runs.

Releases

Notes from what landed
A release's notes are drafted from the changes merged since the last one and their proof, in plain words, for you to edit before it ships.
Built where it runs
Each platform's build runs on a machine of that platform: a Mac for macOS, Linux boxes for each architecture, a Windows machine for Windows.
Signed and published
Builds are signed, published with their checksums, and offered to installed copies as an update, with the notes.
The loop closes
The people who filed the issues a release fixes are told it's out. What users report from the new version arrives as issues, with the version and what they were doing.

Machines

Every install is a node
Anvil on any machine runs threads and checks for the others you've added: macOS, Linux or Windows, on your network or anywhere you can reach over SSH.
A queue that places work
Threads and checks wait in one queue and start on the machine with room that has what they need: the platform, the agent signed in, the repository. A thread can wait for another's branch to land first.
Budgets
Each machine has a budget of agent sessions, and the scheduler keeps to it. Each one's CPU, memory and what it's running are a glance away.
Moving threads
A thread moves to another machine between turns with its conversation and its branch, and carries on there.

People and agents

One list of what needs you
Asks, permissions, reviews requested, changes ready to merge and failed checks you own come to one list across every project, each answered where it lands.
The line, per project
A project says what its agents do on their own and what they ask first. Merging to main and publishing a release ask by default.
Teams
People and agents are members of a project with roles; every change, review and release says who, or which thread, did it.

Building on it

Extensions
An extension is a folder with a manifest and a program in any language, spoken to over JSON-RPC on its stdin and stdout. Extensions add agents, panes, checks, kinds of ask, sources of issues and steps in a release.
The anvil command
Everything above has a command: start a thread on a machine, file an issue, review a change, run a check, cut a release. Scripts and other agents use it as you would.
Tools for agents
Every thread gets Anvil's tools over MCP, so an agent can open a preview, read a check's log, ask you a question or file an issue as part of its work.

Next

Install it, then follow one issue round.

DownloadGetting started takes about ten minutes.