Revolve · open source · written in Rust

It brings its own team.

Give Revolve a goal and it does not stop at one agent. It starts more of them, gives each a role that holds for its whole life, hands out the work, and they talk to each other while they run — held together by a task queue and an inbox that are part of the program rather than something you bolt on.

What you get that you don't get elsewhere

Five things, in the order they matter.

Multi-agent setups that build themselves

You do not wire up a team; the agent assembles one. It starts new agents, gives each a role that sticks for the whole of its life, and every agent can reach every other one by name and ask it something mid-run. A coordinator can send work out, get answers back, and keep going while the others are still thinking.

$ revolve --role coordinator

A task system and an inbox, built in

The backlog is part of the program: every session sees the open tasks each turn, and one can be addressed to a particular agent. Putting one off is a line at the top — until Thursday, until another task is done, until a command succeeds, or until somebody opens a particular file. The other direction is the inbox: anything only you can decide is parked there with what it blocks, instead of an unattended run stalling on a question nobody is there to answer.

$ revolve tasks

Permissions with actual granularity

Every rule is allow, ask or deny, and every prompt offers the same four answers: once, always, always for anything like it, or let the agent propose the rule in words you read before it applies. Rules live per project, a command narrows to its subcommand, a web request to its host, and a file outside the project takes a grant for that one file.

> /permissions

It rewrites its own instructions

What it learns about your project becomes memory it reads on every turn, and it revises those notes from the conversation itself — on request, or on its own after enough has happened. Every revision is a snapshot, so a bad one is undone in one step, and a session started bare ignores all of it when the accumulated instructions are themselves the bug.

> /refine

Sessions outlive the window

A session is its own process answering on a socket, and the terminal is a viewer attached to it. Detach, close the terminal, come back tomorrow and attach again — to that session, or to any of the others still running in the same repository.

$ revolve detach nightly

An input field that is a real editor

What you type into is a text editor, not a prompt line. Several carets, moving a line or a whole markdown section with a keystroke, completing a word from what is already on screen, selecting with the mouse and copying out of the history. A half-written message survives closing the program, and the history you walk with the arrow keys holds what you typed — not what the model was sent.

> Ctrl+Space — complete a word from the conversation
%

It knows what your context costs

A long conversation is re-sent on every turn, so what the provider can read from its cache is most of your bill. The status row shows how much of the last request was a cache hit, so a turn that threw the cache away is visible when it happens rather than on the invoice. Behind it: cache marks that move with the conversation instead of standing still at the prompt, a summarization request built as a strict extension of the one before it, and long tool output cut to a head and a tail as it arrives — with the whole of it kept on disk and readable — rather than rewritten afterwards.

status context 45k/200k (22%), 97% cached

Whatever it runs on is your call

Anthropic, DeepSeek and Z.AI all drive the same agent, through a subscription login or an API key, switchable mid-conversation. The same core answers a terminal, a window, a JSON line protocol and an editor over ACP, so nothing here is tied to one screen or one vendor.

$ revolve --model deepseek:deepseek-v4-pro

Getting it

A binary for Linux or Windows, or a build from source. Either way you need an account with one model provider. Linux is where it is used daily; the Windows build compiles but has not been lived in yet.

Download it

There is no tagged release yet, so there is nothing to download: the program changes daily and a version number would promise a stability it does not have. Building it takes one command and a stable Rust toolchain — that is the box beside this one.

When the first release lands, this is where the static Linux binary, the Windows .exe, their archives with the licenses, the checksums and a one-line installer will be. Watch the releases page if you would rather wait for that.

Build it

$ cargo install --git https://gitlab.com/porky11/revolve-agent revolve

Puts revolve in ~/.cargo/bin. The window is a second binary, revolve-gui, from the same repository.

Point it at a model

$ revolve login
$ export DEEPSEEK_API_KEY=your-key

A subscription or a key, whichever you have. The model you used last is remembered.

Then read one page

The docs start with the commands and the permission rules — the two things worth knowing before you let it run unattended. The rest is discoverable from /help inside a session.