Continuum
Daily-driven since 2025 · macOS · single operator · team mode in pilot

You paste the thread.
You go to lunch.

A Slack thread, a meeting note, an idea on the way out the door. Continuum turns it into ordered tasks, runs the coding agents you already pay for on them, and calls a task done only when the commit is on your remote. Your phone buzzes once: for the one question only you can answer.

Not another AI coding IDE. It sits above your editor and your agents, and drives Claude Code today. Keep both. The alternative is five Claude Code sessions in tmux, with you as their scheduler.

One engineer runs it today. What a lead needs is already written to disk by every task. Putting that on one screen is what the first pilots are shaping.

Your signals, this week one line each · in → verified
mon 09:10 · slack: "checkout retries are silently swallowed"
CAPTURED ·REFINED ·4 BRIEFS ·QUEUED ·IMPLEMENTING
tue 11:40 · meeting: Q3 metrics dashboard for the board
CAPTURED ·REFINED ·7 BRIEFS ·QUEUED ·VERIFIED ✓ on the remote
wed 17:48 · idea: unify auth across the two APIs
CAPTURED ·REFINING NEEDS YOU
stylized from the live surface 1 question waiting for you
Why it exists

One task. Eight sessions.
Everything I typed was "go ahead".

Agents got cheap. Everyone runs more of them. Supervision became the bottleneck, and the bottleneck is a person: someone opening every session and checking every "done". Here is what that looked like from the inside.

Scene one · the scheduler

The agent wrote the code. I opened every session, loaded the context, watched the window fill, saved state, opened the next one. Eight times. My whole contribution, on record, was "resume" and "go ahead".

Capacity went up. The choreography went up with it, and it went up in me.

Scene two · the false done

Four tasks marked done in their state files. Nothing on the remote. Worktrees deleted. $13.50 of work silently destroyed. An agent that says it finished and an agent that finished look identical until something checks.

So I built the thing that checks, and the thing that schedules. That is Continuum.

Monday, after

The thread lands at 9:10. By Thursday, three of four are merged.

Mon 09:10

You paste the Slack thread and close the lid. It lands in an inbox that owes you nothing.

Mon 10:30 · stand-up

It is four tasks now, each with acceptance criteria and an order. One carries a question: split auth into two tasks, or keep one? You answer in a line, from your phone.

Thu 18:04

Three are on origin, checked by sha. The fourth is waiting on a fact only you know. Nobody opened a session by hand.

The typing goes to the agents. What stays with you is judgment: is this in scope, is this true, should this reach the outside world.

How it runs

One task, end to end. A real one.

Every signal rides the same line: in, brief, queue, run, verified. Here is presidio-input-side-pii-scrub, as it happened on 31 July 2026, with its numbers from the file it left behind.

  1. IN
    A two-line ask lands

    "Scrub emails, phones and addresses from raw paragraph text before markdown, without redacting author names." That is the whole input.

  2. BRIEF
    It comes back as a brief

    Goal, what is in and out of scope, the one file to change, three success criteria a stranger could check. 5 turns, $0.34.

  3. QUEUE
    It waits its turn

    The queue runs as many tasks at once as you set, in dependency order. Something blocked stays blocked instead of being started twice.

  4. RUN
    It leaves a file at every step

    It works in stages, and each stage leaves a file before the next may start. If it stalls, you open the file that stopped it. Each stage is a fresh Claude Code session in its own checkout. The receipt is below.

  5. VERIFIED
    Done means origin says so

    PR #125 squash-merged, issue #117 moved, branch deleted. The verdict is read off the remote, not off the agent's notes.

tasks/presidio-input-side-pii-scrub/ what it left behind · every line is a real file
├── brief.md what was asked, exactly
├── exploration.md opened research
├── research.md opened planning
├── plan.md · todo.md opened implementing
├── validation.md what "done" was defined to mean
├── pr.md PR #125
├── sessions/*.jsonl every turn, every cost
└── task.yaml the ledger
Cost by stage from task.yaml · recorded, not estimated
brief $0.34
exploring $0.71
researching $0.70
planning $0.59
implementing $1.70
validating $1.17
task total $5.23 · 86 turns

Every file above is public, unedited. Read the brief that was written before the code, then the validation that was written before "done". Open the directory → · how it works →

The rails

What reaches you. What it never does.

NEEDS YOU · only three things
  • A scope call. Split this in two, or keep one?
  • A fact only you know. Which of these two APIs is the one customers hit?
  • An outward-facing effect. Anything that would reach a customer, a vendor, or main.

The question reaches you as a Telegram message; you answer there or in the terminal. Everything else is decided for you, with the reason written down and a link that reopens the exact moment. You can disagree after lunch.

Never, without you
  • Never works on main. Each task runs on its own branch, in its own checkout, and pushes it so nothing is lost.
  • Merges only what passed. A task is squash-merged into the branch it was cut from after its own validation passed, and the combined tree is checked again. Releases, deploys and anything that reaches a customer wait for you.
  • Never spends past the limit you set. How many tasks run at once is a number, not a habit.

It runs on your machine, on the model subscription you already have. No server, no account, no copy of your code anywhere new. architecture →

Proof

Don't take the page's word. Open the file.

The whole directory is here, unedited: the brief, every stage file, every session log, the ledger. Open the directory →

The ledger: cost is recorded, not estimated

# task.yaml · presidio-input-side-pii-scrub · unedited
status: done        pr: 125   issue: 117
last_action: 'Squash-merged PR #125. Issue #117 → In Review. Deleted remote branch.'
sessions:
  - mode: EXPLORING     turns: 19  cost_usd: 0.7143
  - mode: RESEARCHING   turns: 13  cost_usd: 0.7039
  - mode: PLANNING      turns: 7   cost_usd: 0.5935
  - mode: IMPLEMENTING  turns: 28  cost_usd: 1.7037
  - mode: VALIDATING    turns: 14  cost_usd: 1.1695
validation_verdict: approved

The last_action line was written by reading origin, not by asking the agent. task.yaml →

The check: "done" was written down before it was claimed

# validation.md · what "done" was defined to mean, then checked
| Criterion                                  | Verification                          |
| Emails/phones/addresses redacted;          | TestPiiScrub asserts markers appear;  |
|   author names preserved                   |   result.authors still intact         |
| Redaction logged, PII value never logged   | caplog test: type + index, no value   |
| Pipeline continues; no paper dropped       | paragraph count unchanged             |

## Pass bar — actual results
[x] TestPiiScrub 8/8 passed
[x] tests/test_ingestion.py 33/33 passed
[x] full suite 344 passed, 1 failed (pre-existing Hypothesis flake, unrelated)

validation.md →

Where it has run

Six of our own repositories and one commercial engagement, since 2025. More than a thousand tasks, each with a directory like the one above. The commercial engagement is not yet cleared for publication; ask and we will say what we can on the call. Before any of this existed, thirteen agents ran in parallel here by hand; the postmortem is where the rails come from.

3,057 sessions and 45,485 turns, counted from the task.yaml files across six repositories. more evidence →

Where it stands

What is already on disk for a lead.

Every task writes its cost per stage, every routine decision with its reason, and a verdict read off origin. One engineer runs the line today. Team mode puts those files on one screen; the first pilots are deciding what that screen shows first.

No database: state is YAML and markdown in your git, which is why a task outlives a session, a branch, a machine, and the model vendor underneath. How it works →

Continuum is closed and in early access. The behavioural standards it runs its agents under are open source and already used by other developers in their editors. If you want to see how the agents on this line are made to behave, start there.

There is no free tier and there will not be one. The standards →

Questions

Before you ask.

Is Continuum another AI coding IDE? +

No. It sits above the editor and the agent. They execute; Continuum writes the task they run, merges it only after its own validation passed, and refuses to take their word for done. Keep whatever editor and agent you already use.

Where does my code and work state live? +

In your repositories and your git. Work state is YAML and markdown in a directory beside the work. There is no server, no account, and no second copy of what is true.

Which models, and what does it cost to run? +

Model-agnostic by construction; today it drives Claude Code on the subscription you already pay for. Continuum adds no API-key metering and no per-token markup. Every task records its own inference cost in task.yaml; the one on this page cost $5.23 over 86 turns.

Can I use it today? +

It has run its creator's daily work since 2025 and is being hardened for outside users, on macOS. It is not publicly installable yet. The open-source standards layer runs in your editor today. For early access or a pilot, ask.

Can my team use it? +

One engineer at a time today. A pilot is how a team finds out what the lead's screen must show.

Compared to Devin, Factory, Copilot and the rest: in the docs →

One repo. Two weeks.
One thread you have been avoiding.

Continuum is daily-driven and being hardened for its first outside users. A pilot is one repository, your existing agents and subscription, and a real backlog. At the end you keep every brief, receipt and merge, whether or not you keep Continuum.

macOS today. No server, no account, nothing to stand up.

The thesis, if you stayed

Intent is the input. Code is a byproduct. A layer has opened above the editor: its input is raw intent, its output is code verified on the remote, and the discipline in between is deciding what deserves you. We call that layer Intent Engineering. Continuum is a workstation for it.

Five claims, and the mechanism where each one stops being a belief: that is the short version. The essay is the long one.

The discipline, and how this applies it → · The founding essay →