Abacus 0.6.0 is out — the biggest release since we started pointing our models at real codebases. Same one Rust binary, same "runs on the model you own" stance, but the agent itself got the thing we're told isn't possible: a memory.
Most coding agents are amnesiacs. Brilliant in the moment, and forgetful the
moment the session ends. Every new session starts from zero, relearns the same
conventions, and re-pays the same debt — and the model that starts on day eight
is exactly the model that started on day one.
Abacus is built on a different bet: an agent should get better at yourrepository the longer it works there, and never learn the same lesson twice.
0.6.0 is that bet shipped. Six mechanisms do it, and they all stay local to
~/.abacus/
— nothing leaves your machine unless you send it.## What's in the loop
Papercuts remember failures. When the agent works through a snag, it records
the lesson — what went wrong, the fix that worked, and tripwires: the distinctive
strings from the error output. Every later tool call is scanned against those
tripwires, and when one matches, the lesson comes back exactly where it's
needed, in the tool result. A papercut that stops being needed decays away over
a two-week half-life instead of nagging forever.
Memories remember knowledge. Architecture facts, decisions and their
reasons, conventions — recorded and curated by the model itself, injected at the
start of every turn. Re-recording updates, forgetting is curation, and it was
never meant to be hoarded.
Tethering holds the session to its intent. After the first answer, a quick
call snapshots what you're trying to achieve. Every ~35 steps a drift check runs
and asks a fair question: is the recent work still serving that intent? What
you'd expect from a tool that runs long sessions — an anchor you don't have to
hold yourself.
The hive is earned delegation. Confidence is recorded from actual swarm
outcomes, and a maturity tier — probing, swarm, hive — decides how the agent
parallelizes work. It earns the right to delegate by doing it well, the same way
a good engineer does.
Every model call is a training trace #
The piece we're most proud of sits quietly at the bottom: with tracing on (the
default), every model call is captured as the task it was actually given —
system prompt, rolling summary, and mode context included — one JSON record per
call. Not a log of what happened. The exact input a fine-tuner needs.
This is the same discipline that made Qwythos what it is. rethink built our
500M+ tokens of verified chain-of-thought data, and now every Abacus session is
a potential contribution to that pipeline. The agent that runs your codebase is
also, when you choose, teaching the next one.
Three protocols, any model #
Under the hood, 0.6.0 adds a third native wire protocol — the Anthropic
Messages API — alongside OpenAI-shaped chat completions and the Responses API,
each with its own streaming parser. The agent turn is model-agnostic; the
protocol is just transport. Front a frontier API, or a Qwythos on the machine in
front of you — Ollama, llama.cpp, vLLM all work. "Any model" isn't a slogan here;
it's the architecture.
It also ships the practical stuff that a long-lived tool needs: scripted
endpoints for custom backends, an auxiliary model for cheap background calls,
reasoning effort you can dial per profile, and the same approval-gated,
PLAN/BUILD discipline that has always kept every mutation shown as a diff before
it runs.
If you run a local model and have ever been told the frontier is the only place real work happens: this is the agent that runs on the model you own, and gets
better the longer it works there. That's the argument, and it's now the
product.
*Abacus is open source, Apache-2.0. It's on GitHub — the same repo this site
points you to. Try it against a Qwythos on your own machine; it's where our
models go to work.*