Anvil takes the work froman issue to a release.
The environment your agents and your team write code in, and the forge the code lives in, as one thing: an issue, the thread on it, the change, its review and checks, and the release are one piece of work, in one place.
Fig. 1One fix, round the loop
Clicks in the composer don't take focus while a terminal is open.
Ran 3 commands, edited 2 files
Try it with the preview open too.
Ran go test, opened a web preview
$ go test ./... ok anvil 1.84s $
Where the work lives now
An agent writes the change in one tool. The change is reviewed, checked and shipped from another.
The agent runs in a terminal or an editor. The forge is a browser tab: the issue the work came from, the review, the CI run, the release it goes into. Between them is a person copying: the issue pasted into a prompt, a reviewer's comment retyped for the agent, a CI log pasted back into the terminal, the release notes written from memory.
And each side sees half. The agent can't see that a check failed on its branch, or that a reviewer asked a question. The forge can't see that the agent is waiting for an answer, or why it changed what it changed. Every handoff is a place where work waits.
How the work moves in Anvil
-
An issue starts the thread.
Someone files an issue, or a user's report, a failing check or a line in a review becomes one. The project's Lead reads it, says what it means to do, and starts a thread on it: an agent, on a branch of its own, on whichever of your machines has room. From then on the issue shows the work happening.
An issue's timeline: the Lead's plan, then the thread it started, live.OpenUpload retries give up after one 503#212Filed by Mara Lind · bug · uploads- Lead: a retry with backoff in
upload.go; starting a thread. - Retry uploads is working, Claude Code on workbox
- Lead: a retry with backoff in
-
The thread's branch is the change.
The thread works in real terminals: it runs the tests, starts the app, opens a preview, and commits as it goes. When it's done, the change opens from the same branch by itself, and the conversation that made it stays attached, so every commit comes with the reasoning behind it.
A thread works on a branch of its own, in a worktree of its own, so four threads in one repository never trip over each other. -
The change arrives with its proof.
What's now true, screenshots from the running app, the checks that ran and where, the size of the diff, and a link to try it while it runs. Reviewers read that before they read a line of the diff, and the question at the end of it is the one decision left: merge it or not.
Openretry-upload → main · opened by the thread for #2122mRetry uploads on a 503An upload that gets a 503 retries with backoff (1, 2, 4, 8 s) before it gives up, and says so in the log. A test fakes the 503s.
Before: one 503 and it stops After: retried twice, then uploaded - Checks that ran
- go test ./...this Mac
- e2e · Linuxworkbox
- e2e · Windowswin-box
- Change
- +61 −9 in 3 files · try it on workbox:8080
1Merge recommended2Hold it3ReplyFigure 2. A change a thread opened, as a reviewer finds it: the proof first, then the question. Reply sends your words to the thread that wrote it. -
Review talks to the thread.
A comment on a line goes to the agent that wrote the line, and comes back as a commit with a reply. Ask why, and the thread answers from the work it did. People review agents' changes, and agents review people's when you ask them to.
A line's review, answered with a commit on the change's branch.MLMara Lind onupload.go:42Cap the wait, so a dead server doesn't hold an upload for minutes.
RRetry uploadsCapped at 8 s, four tries.
c19e0a4 -
A failing check goes home.
Checks run on your machines, the same ones threads run on, on every platform you ship. When one fails, its log goes to the thread whose commit broke it, which fixes it on its branch and runs it again. You hear about it only if it can't.
- go test ./...this Mac
- e2e · Linuxworkbox
- e2e · Windowswin-boxSent to Retry uploads: the fake server's port was taken
- e2e · Windows, againwin-boxFixed in
5d2e81b
-
What lands, ships.
Approved and green, the change lands and its issue closes. The next release's notes are written from what landed and its proof; each platform builds on a machine that runs it; the people who filed the issues hear it shipped. What they report from the new version is the next issue.
A release, from the changes that landed since the last.PublishedHarbor 1.4.0- Uploads retry a 503 with backoff.
#213 - Large files resume where they stopped.
#208
macOSLinuxWindowsCloses #212 and 6 more · 11 people told - Uploads retry a 503 with backoff.
Who decides
People decide. Agents do the rest, and each project says where the line is.
A project lists what its agents do on their own and what they ask first: open changes, fix their own checks and rebase, say, but ask before merging to main or publishing a release. Every ask comes to one list, whatever it's about and whoever asked, and an answer goes straight back to the work waiting on it.
# .aide/config.toml
[agents]
may = ["open changes", "fix their checks",
"rebase", "review when asked"]
asks = ["merge to main", "publish a release"]
A project's line between agents and people, in its own repository.
Every machine
Every Anvil is a node: your laptop, the box under the desk, the team's server.
Threads and checks go to whichever machine has room and runs what they need, on macOS, Linux or Windows. A thread moves between machines with its conversation and its branch. One node, on a server, is the team's forge: the repositories, issues, changes and releases everyone shares.
Download
Anvil 0.6.1, for every platform you work on.
curl -fsSL https://anvil.nate.rip/install.sh | shOn Windows: irm https://anvil.nate.rip/install.ps1 | iex. Every way to install, and how to check a download: Download.