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 issuesCloning 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
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.