detent

Run coding agents against a queue of tasks, and let nothing finish until your own checks pass.

detent dispatches Claude Code at one task per repository at a time, holds each behind that repository's own gauge on the way out, has a second model read every green diff, merges what survives into a branch of its own — and writes down what each run cost in attempts, time and money.

The constraints are in the code, not in the prompt.

A detent is the catch that holds a mechanism in a defined position until it is deliberately released. Here it is released by a green gauge, and by nothing else.

npm i -g @kazimvakhobov/detent

Node 22, macOS or Linux, and Claude Code installed and signed in. detent drives the agent you already pay for and ships none of its own. Zero dependencies.

detent.kazimvakhobov.com is the site, and the dashboard is live on it — the real detent dashboard, built from this version's code against a made-up product, with a task running in it. Nothing on it is a mockup: the answers are the real server's, taken when the site was built.

The three claims

When is the agent allowed to stop? Not when it says it is done — when the project's checks pass. The gauge runs on the agent's way out; red means it does not get to leave, and it is handed the failure text to work from.

Was it worth it? Every run is a line in a journal: which model, how many rounds it took, which stage it died on, how long, how much. That turns "which model should run this repository" from an opinion into a number.

Who says it is done? A second model reads the diff against the task's acceptance criteria, and it may demote, never approve. Green is granted by machine checks. A model's judgement can only raise a doubt — which costs the agent another round, and on the last one sends the task to a person. Otherwise "proven" quietly becomes "a second model agreed".

It builds itself, and here are its numbers

Since 2026-10-13 the tasks in this repository have been dispatched by detent run, held behind the gauge, read by the acceptance pass and merged by the tool. git log --grep='^Acceptance: ' is the record, and nobody typed those trailers by hand. Where that is not true the commit says so itself: the tasks after 0.9.0 were worked in a session and merged by hand, and each says as much in place of the Gauge: and Acceptance: trailers it does not carry.

From this repository's own journal
Runs recorded	39
Pass rate	72%
Cost per task that landed	$10.52
Green runs the reviewer read	36
…of those, demoted	22%

That last row is the number the product exists to produce: almost a quarter of the runs whose machine checks were green had not actually done the task. Every one of those was a person's hour that a passing test suite would have told nobody about.

The task files are still written by a person, and so is everything past agent/dev: the pull request, the tag, the release.

How a run goes

A task is a markdown file. The frontmatter is bookkeeping; only the body reaches the agent — the spec written before the work is the prompt.

---
id: 0001                 # the order tasks run in, and the file name
repo: acme-api           # which repository in product.json it is in
touches_contract: false  # true makes it a barrier: it runs alone, and
                         # no higher number starts until it has passed
---

# Goal

One paragraph: what must work when this is done.

# Acceptance criteria

- [ ] a checkable statement

# Out of scope

What not to do while you are in there.

Save it as tasks/todo/0001-wallet-endpoint.md and run detent run. Then, for up to attempts rounds (default three), each call to a model bounded by timeout minutes (default thirty):

flowchart LR
  todo["tasks/todo/<br/>0001-wallet-endpoint.md"] --> agent["the agent's turn<br/><small>a prompt and a directory</small>"]
  agent --> gauge{"exit gauge"}
  gauge -- "red: the failure text<br/>one round spent" --> agent
  gauge -- green --> accept{"acceptance pass"}
  accept -- "a doubt<br/>one round spent" --> agent
  accept -- "no doubt" --> dev[("agent/dev<br/>one merge commit")]
  agent -. "out of rounds, a conflict,<br/>a broken run" .-> hold["tasks/hold/<br/>branch kept, work parked"]
  hold --> told(["you are told"])
  hold -. "you resume it" .-> todo

  classDef ok stroke:#1f7a4d,stroke-width:2px
  classDef stop stroke:#9a6100,stroke-width:2px
  class dev ok
  class hold,told stop

1. the agent's turn — a prompt and a working directory, and nothing else
2. the exit gauge — the repository's own checks. Red hands back the failure text and costs one round
3. the acceptance pass — a second model reads the diff. A doubt hands back the doubt and costs one round, the same budget the gauge spends

This is the beginning of the README. Read the rest at the original. Read the full README ↗