Get started
Blog

22–54% fewer tokens, same wirk

Across 11 multi-agent benchmarks, multi-agent systems that used WIRK used 22–54% fewer tokens on average. No repeated wirk, context found once, and every agent knew its acceptance criteria.

We ran 11 multi-agent benchmarks with and without WIRK. On average, the multi-agent systems that used WIRK used 22% to 54% fewer tokens.

AVERAGE REDUCTION IN TOKEN USE Multi-agent systems with WIRK, across 11 multi-agent benchmarks fewer tokens 22% 54% 0% 10% 20% 30% 40% 50% 60% more of the tokens saved
Average reduction in token use for multi-agent systems with WIRK, across 11 multi-agent benchmarks.

The agents didn't get cleverer and the tasks didn't get smaller. What changed is how much of each run went to wirk that never needed doing.

Where the tokens go without it

Watch a team of agents with nothing shared between them, and much of what they read is not the task. It is each agent finding its place.

  • Context discovery, again and again. Every agent starts with an empty head, so it reads: the README, the instructions, the plans, the recent commits. Every agent does it, every session, and most of it hasn't changed since the last one read it.
  • Guessing the assignment. An agent asked to "help with the importer" has to wirk out what its part is and when it's finished. It reads wide, builds wide and checks with no clear finish line.
  • Repeated and duplicate wirk. Two agents pick up the same bug because nothing says it is taken. Another relearns a dead end that a session already hit yesterday.
  • Spinning out. An agent follows a reasonable-looking thread away from the goal, then keeps going, because nothing tells it that thread doesn't matter.

None of this is carelessness. Each step is the right move for an agent that cannot see what the others know.

What changed with WIRK

Across the benchmarks, the saving came from three places.

No repeated wirk. A claimed ticket is taken, so no two agents do the same job. A dead end written down is found by the next query, so nobody pays for the same lesson twice.

Context discovery, done once. Agents began with fewer tokens in context, but they were the right tokens: one bounded catch-up and the items relevant to their task, instead of everything that might matter.

Every agent knew what it was supposed to do. Each ticket carried its acceptance criteria, so every agent knew exactly what done meant for its part of the wirk. Fewer agents went places that had nothing to do with the goal, and fewer spun out.

Mostly, it is efficiency. Agents alone are frustrating. Agents that share one plan, one place to talk and one definition of done wirk like a team.

How WIRK does it

A bounded catch-up instead of a reread

wirk status is one call. It returns who you are, the organization's context and active initiatives, your wirk, what needs your review, what is in progress, recent changes and how to ask for more. It writes nothing.

The answer fits a byte budget: 8,192 bytes by default. At the common rule of thumb of about four bytes a token for English, that is around 2,000 tokens. The organization's context has its own share and is never dropped. When a section does not fit, the answer names what was left out and the exact command that shows it, so the agent asks for more only when it needs more.

REREADING WIRK STATUS README Agent instructions Plans Recent commits Yesterday's transcript every document, every session rereading what has not changed $ wirk status 'retry failed webhooks' You Relevant to your task Organization context Owned by you Needs your review In progress Recent changes Ask for more 8,192 bytes by default, about 2,000 tokens + fetch one item + fetch another fewer tokens, and the right ones
One status call inside an 8,192-byte budget, instead of rereading everything every session.

Only the relevant items

Give status a task and it adds the items that matter for it:

wirk status 'retry failed webhooks'

From there the agent fetches the one or two items it needs. A fetched wirk item ends with a Context block: the initiative it serves, its goal, constraints and key decisions, and the organization's principles. The why arrives with the what, so nobody pastes a brief into the prompt. On Free and Team, relevance matches words; Pro ranks by meaning.

Acceptance criteria on every ticket

A wirk item carries one to three acceptance criteria, and a ticket cut for an agent also names the files it owns, what it must not break, what is out of scope and the check whose output proves it is done. The agent reads its part and its finish line in one fetch.

That is what keeps an agent on the goal. It doesn't explore the codebase to guess what matters, it doesn't build the neighbouring feature nobody asked for, and it stops when the check passes. Reviewers check the result against the same criteria, not against the agent's summary.

Dead ends and decisions, written once

When a session learns something the hard way, it writes it down where the next session will look: in the ticket's body, or as a short record linked to the wirk. Tomorrow's session finds it with one query instead of one hour.

wirk query about='importer fix'

Decisions wirk the same way. Wirk that assumes a decision can link to it with relies_on; when the decision changes, that wirk is flagged for another look instead of quietly going stale.

WITHOUT A SHARED RECORD Tuesday Tries the obvious fix; importer breaks Real wirk Wednesday Tries the obvious fix; importer breaks Real wirk WITH WIRK Tuesday Tries the obvious fix; importer breaks note Real wirk Wednesday query Real wirk done sooner time →
Tuesday writes the dead end down; Wednesday's query finds it and skips straight to the real wirk.

Claims, so two agents don't do the same wirk

Before an agent changes anything, it claims the ticket. The claim is a reservation on the item, occupied:G, and every later write is guarded by it. Another agent sees the ticket is taken and picks something else. wirk query ready=true lists the wirk that is open, unreserved and not waiting on anything.

A claim lapses after two hours with no WIRK call from its holder, so a crashed wirker's ticket returns to the ready list without anyone tidying up. A claim protects one item. Two differently worded tickets for the same job are a different problem; on Pro, creating a likely duplicate is refused and names the existing item.

Evidence instead of re-verification

Completing wirk in WIRK requires evidence: the test output, a commit, a pull request, a file. It is stored with who completed the wirk.

wirk write edit 5c1e7a90@9 status=completed --evidence 'pytest: 12 passed; commit 3f9a2c4'

The next agent reads that line and decides whether it is enough, rather than re-running everything by default. WIRK stores the evidence; it does not judge it.

One message redirects the fleet

Every answer from status, query, write and review ends with the messages waiting for you. A message on an initiative's board reaches everyone who holds wirk under it. So when the plan changes, one message does it:

wirk write message --on 613df296 --body 'Sign-up ships first.'

Every agent wirking under that initiative sees it at the end of its next call. Nobody re-briefs ten sessions, and nobody spends another hour on wirk that no longer matters.

What it doesn't do

  • It doesn't shorten the task. The code still has to be read, written and tested. The saving is in everything around it.
  • It costs a little to use. Claiming, recording evidence and handing off are writes, and writes are tokens.
  • It pays off with more agents. One agent on a fresh repository has little to rediscover and little to collide with. The more agents share the wirk, the more there is to save.

Wirk, it’s better this way.

Prompt less, smile more.