Agent work orchestration · Detent Cloud or self-hosted

Your process, at agent speed.

You put an issue in Todo. A runner on a machine you control claims it, runs Codex or Claude Code against the contract you checked in, and moves it between the states your workflow defines, holding it wherever you put a gate.

Instead of steering one agent through a chat, you run your own process across many agents at once.

Start free on Detent Cloud

See plans Self-host

Free plan: 2 concurrent runs, no card. Self-hosting is free. v0.177.4 · you bring the model cost.

composed snapshot 2 working 1 held at gate 3202 merged, all time tokens, budget, and rate limit on the dashboard

Todo 2

#1626 detent

feat(admission): surface pending proposals

#1619 detent

feat(health): surface stranded active work

In Progress 2

#1614 detent

chore(safety): guard dispatch capacity paths

agent working

#1611 detent

fix(scheduler): clean orphan cycle state

make check running

Human Review 1

#1585 detent

fix(orchestrator): add token progress brake

held at the gate

the detent,
released only by you

Rework 1

#1593 detent

fix(board): collapse staleness warnings

2 threads unresolved

Merging 1

#1628 detent

docs(cli): refresh version output example

rebased, CI watch

Done 3202

#1624 detent

test(project): relax watcher deadlock guard

merged, green

The six lanes shown come from Detent's own production configuration, not a fixed product state model; each workflow defines its own states. This is not a live board: the issue numbers and titles come from real merged work in digitaldrywood/detent, composed across the path for this illustration. The counts describe the illustration; 3202 is the all-time landed pull requests on that repository. Lanes for other kinds of work ↑

Any kind of work

Your lanes. Your definition of done.

Detent is an orchestration layer, and the work it moves does not have to be code. A project's detent.yaml names its lanes and gives each one a role: active lanes dispatch an agent, holding lanes wait, terminal lanes end the work. Code is one shape. A video pipeline or an office workflow is another.

Software

Todo In Progress Human Review Merging Done

Video

Script Record Edit Review Published

Office

Request Draft Approval Filed

Illustrative lane sets, not shipped templates. The amber lane is a holding lane that waits for a person; yours can sit anywhere, or nowhere.

02 · Definite states

A detent makes position definite.

A detent is the catch that holds a moving part at a defined position until it is deliberately released: the click-stop on a dial, the notch on a ratchet. It does two things at once. It resists movement out of a position, and it makes the set of positions definite. Detent is named for the second one.

Where is it?

Autonomy-first: You steer a session and course-correct when it drifts.
Detent: At a state your workflow defines, on the board.

What is it waiting on?

Autonomy-first: Whatever you tell it next.
Detent: The gate you configured: your gate command on the finished change, an automated validator, or a person in Human Review.

Who moves it?

Autonomy-first: You, by talking to the agent.
Detent: The runtime when the condition is met, or you by changing the state.

The board above and the lane rail below show where each piece of work sits. It is always at a state the workflow defines, so you never have to read through an agent session to find it.

Why the name ↗ Promotion conditions →

03 · The inversion

Where the intelligence lives.

Autonomy-first tools put the intelligence in the agent and ask you to supervise it. Detent puts the intelligence in your spec and supplies the discipline. Same task, two interaction models.

autonomy-first assistant: “add OAuth token rotation”

It starts as a prompt. The agent picks a plan.
You read the plan and inspect partial edits.
It misses the migration. You redirect.
It skips the tests. You redirect again.
You are the supervision loop.

Detent: “add OAuth token rotation”

It starts as an issue naming the storage change, CLI behavior, migration, rollback, and tests.
A runner executes that contract in an isolated worktree.
It produces a reviewable Change Request.
It does not land until your gates clear.
Your process runs. You read one change.

Detent scales the judgment of people who already hold a high bar. It applies your rules the way you would, every time and in parallel, and every step stays visible on the board.

04 · How it works

Your lanes. Your gates between them.

The Hub's board is the state machine. Runners on your machines move work through it, and your gates decide when it advances.

Todo—— In Progress—◂— Human Review—◂— Merging—◂— Done

Rework

The notch marks a gate you defined. Lanes are workflow-defined: this is the delivery path. Detent's own board also configures Backlog, Blocked, and Cancelled.

1. Pick a Hub

The Hub holds the board, the issues, the review decisions, and the policy each project runs under. Use Detent Cloud, or run the same Hub yourself.

2. Enroll a runner

A runner is a machine you enroll: a laptop, a build server, a VM, or a Fly Sprite. It keeps your checkout, your agent sign-ins, and your toolchain.

3. Commit the contracts

detent.yaml is the machine contract: lanes, gate command, review policy, scheduling, retries, and budgets. WORKFLOW.md is the agent contract: how to work in this repository and what done means.

4. You put an issue in Todo

A runner that holds the project claims it, creates an isolated worktree, and starts Codex or Claude Code with the issue and WORKFLOW.md. The issue moves to In Progress.

5. Gates decide

With review.human: false an accepted change goes straight to Merging. With review.human: true it waits in Human Review until a person approves it or sends it back.

6. Landing is serialized

In Merging, the runner that holds the project lands the change on the base branch with plain git, one change at a time. Then the issue is Done.

The mechanism in full, with the gate model and worktree isolation →

05 · Landing

One change lands at a time.

In Merging, the runner that holds the project lands the accepted change on the base branch with plain git, one change at a time. Parallel agents never race each other onto your main line.

accepted changes queue→ Merging→ land on the base branch→ Done

A change that cannot land goes to Blocked with its reason instead of landing broken. Native projects make no GitHub API calls by default; git clone and push work against any host. Board states →

06 · The operator surface

The board stays honest.

Live counts, running agents, budget and capacity, reports, and activity. "In progress" means an agent is actually working right now.

Detent Cloud demo board in dark mode with Todo, In Progress, Blocked, and Merging lanes; the sidebar and empty lanes are collapsed.

The same board is available over MCP, so your own agent can file issues, read run history, and review changes. The CLI reads it too, from any runner.

Tour the operator surface →

07 · Contracts, shown

Config you can read beats adjectives.

Two files, committed to your repository: the machine contract and the agent contract. Both are excerpted here from Detent's own repository, which Detent builds on Detent Cloud.

detent.yaml digitaldrywood/detent

tracker:
     kind: hub_native
     repository: digitaldrywood/detent
     lanes:
         - name: Todo
          role: active
         - name: Human Review
          role: holding
         - name: Done
          role: terminal
 review:
     human: false
 gate:
     kind: command
     run: "make check-landing"
     ci_failure_action: rework
     validator:
         enabled: true
     security_audit:
         enabled: true

WORKFLOW.md the agent contract, checked in and portable

You are working on **Detent**, the Go agent
orchestrator, on native Detent Cloud work item
{{ issue.identifier }}. The issue and its
decisions live on Detent Cloud.

 Follow CLAUDE.md and AGENTS.md; they are the project
authority for layout, formatting, validation, and
review conventions.

The lanes above are an excerpt; Detent's own board configures nine. Trusted workflow definitions from the repository's default branch apply automatically. You can keep reading by hand too; nobody will revoke your keyboard. The whole file ↗

08 · Proof

It ships itself.

Detent is built on Detent Cloud. Its issues live on the Hub, runners pick them up, and the agents they dispatch write the changes that land in digitaldrywood/detent.

Its detent.yaml and WORKFLOW.md are in the repository, readable as a starting point for your first project.

Read Detent's detent.yaml ↗

2026-07-02 · 2:20 · Detent v0.20.1

I Opened Seven Issues for One Feature (On Purpose)

One feature. Seven real issues. Four hours. Zero babysitting.

Demonstrates

A seven-issue dependency graph completed in merge order.
Detent returned dependent work to Todo after its prerequisite merged.

Watch on YouTube ↗ Transcript →

09 · Runners

Your machines do the work.

A runner keeps your repository checkout, your agent sign-ins, and your toolchain. Nothing that touches your code runs on the Hub.

A laptop

Enroll the machine you already work on and let it pick up issues while you review.

A build server

Put the runner where your toolchain, caches, and secrets already live.

A VM

Run as many as your plan's concurrent work allows, each routed to its own projects.

A Fly Sprite

Cloud runners on Fly Sprites, with Luna walking you through setup.

Enroll one from Settings › Providers & runners. It runs detent hub runner register once and installs a background service. Cloud assigns each runner its allowed projects and model selection. Runners on Fly Sprites →

10 · Get started

Start on Detent Cloud. Your runner does the work.

1 Create an account at cloud.detent.build and create or join an organization.
2 Create a project. New projects start with Todo, In Progress, Merging, Done, Blocked, and Human Review; change them to fit the work.
3 Commit detent.yaml and WORKFLOW.md to the repository the project works in.
4 Install Detent on the runner machine and sign in there to Codex or Claude Code.
5 In Settings › Providers & runners, choose Enroll a runner and run the command it shows.
6 File an issue in Todo and watch it move across the board.

Create a free account Cloud onboarding guide

Rather run it yourself?

The Hub is the same binary. Self-hosting is free and needs no Detent Cloud account or billing. You need one host, SQLite, and a TLS proxy in front.

Self-host the Hub →

Homebrew, if you already manage CLI tools with brew

brew install digitaldrywood/tap/detent

Or build from source with Go

go install github.com/digitaldrywood/detent/cmd/detent@latest

Upgrade with brew upgrade digitaldrywood/tap/detent.

enroll the runner

$ detent hub runner register --url https://cloud.detent.build/organizations/ORGANIZATION_ID \
     --token TOKEN --name "Build host" --service
   creates the runner's identity, writes its configuration, and installs a background service