Anvil

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.

Download Anvil Version 0.6.1 for macOS, Linux and Windows
Getting started · Features

Fig. 1One fix, round the loop

Figure 1. One fix going round: the issue, the thread it started, the change and its review, a failing check sent back to the thread that caused it, and the release it ships in. Then a Lead with four threads at once.

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

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

    OpenUpload retries give up after one 503#212
    Filed by Mara Lind · bug · uploads
    1. Lead: a retry with backoff in upload.go; starting a thread.
    2. Retry uploads is working, Claude Code on workbox
    An issue's timeline: the Lead's plan, then the thread it started, live.
  2. 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.

    Retry uploads branch retry-upload · change #213 main main moves on merged 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.
  3. 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 #2122m
    Retry uploads on a 503

    An 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 it3Reply
    Figure 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.
  4. 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.

    ML
    Mara Lind on upload.go:42

    Cap the wait, so a dead server doesn't hold an upload for minutes.

    R
    Retry uploads

    Capped at 8 s, four tries. c19e0a4

    A line's review, answered with a commit on the change's branch.
  5. 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
    A check that failed, the thread that fixed it, and the same check again.
  6. 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.

    PublishedHarbor 1.4.0
    • Uploads retry a 503 with backoff. #213
    • Large files resume where they stopped. #208
    macOSLinuxWindows
    Closes #212 and 6 more · 11 people told
    A release, from the changes that landed since the last.

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.

this MacmacOS3 threads · CPU 38%
workboxLinux5 threads, 2 checks · CPU 72%
win-boxWindows1 check · CPU 20%
forge.teamLinuxthe team's repositories
Machines, with what each is running.

Download

Anvil 0.6.1, for every platform you work on.

curl -fsSL https://anvil.nate.rip/install.sh | sh

On Windows: irm https://anvil.nate.rip/install.ps1 | iex. Every way to install, and how to check a download: Download.