DIRECT mode

§ DIRECT

DIRECT is where Octopush stops being a chat and becomes an orchestra. You define a pipeline: a sequence of stages, each handled by an agent with its own role, model, and tools, with human checkpoints between them. Then you run it and watch the work move from stage to stage.

Where TALK is one agent in one conversation, DIRECT lets you compose many — a planner that scopes the work, an implementer that writes it, a reviewer that critiques it, an approver that gates it. DIRECT is optional per workspace, and it’s the part of Octopush that has no real equivalent in a normal editor.

How to open it

Press ⌘⇧D, or click Direct in the mode switcher. DIRECT is opt-in per workspace.

[screenshot: DIRECT mode run track — horizontal stage cards numbered with roman numerals]

The interface

Stages

A pipeline is a chain of stages. Each stage has:

• A role — one of planner, implementer, reviewer, approver, or debugger. The role shapes what the stage is for.
• An assigned model — picked per stage, and overridable per run so you can swap in a stronger or cheaper model without editing the pipeline.
• A substrate pill — either API (the stage runs against the Anthropic API) or CLI (the stage runs Claude Code CLI directly inside the worktree). The pill tells you, at a glance, where each stage’s work happens.
• Enabled tools — the set of tools that stage is allowed to use.

The pipeline builder

Pipelines are authored in a visual graph editor. Drag stages, connect them, set roles, assign models, and choose substrates and tools — all without writing config by hand.

[screenshot: the visual pipeline builder graph editor]

Checkpoints

Between stages you can place checkpoints, marked with the ⟜ glyph. When a run reaches a checkpoint it pauses and waits for a human. You can:

• Approve — let the run continue.
• Reject with feedback — stop and send your notes back.
• Send back to a stage — return the work to an earlier stage to be redone.
• Resume — restart a run that halted for a transient reason (a rate limit, for example) without re-deciding the work.

Review loops

A reviewer stage can loop: send work back to an implementer, get a revision, review again. Octopush tracks the iteration as N of M and surfaces exhaustion when the loop hits its limit without converging — so a pipeline can’t spin forever.

The run track

A live run is shown as a horizontal track of stage cards. Each card carries a roman numeral (I · II · III …) and a status glyph, and the cards are connected by ⟶ for a normal hand-off and ⟜ where a checkpoint sits.

[screenshot: run track with a checkpoint pause and an active review loop counter]

The cost ledger

DIRECT’s cost ledger is savings-first. Instead of only showing what you spent, it frames the run against the all-premium baseline:

saved $X · Y% under all-premium · spent $Z

You can set an optional per-run budget, and expand the ledger for a per-stage breakdown of where the money went.

A typical flow

1. Press ⌘⇧D and open the pipeline builder.
2. Add a planner stage on a cheaper model, an implementer on a stronger one, and a reviewer after it.
3. Choose a substrate per stage — API for the planner, CLI for the implementer so it edits the worktree directly.
4. Place a checkpoint (⟜) before the implementer so you approve the plan before any code is written.
5. Wire the reviewer to loop back to the implementer, capped at a few iterations.
6. Start the run, optionally overriding a stage’s model for this run only.
7. At the checkpoint, approve, reject with feedback, or send back to a stage.
8. Watch the loop counter (2 of 3) as the reviewer and implementer converge.
9. When it finishes, read the ledger: saved $X · Y% under all-premium · spent $Z, and expand it for the per-stage breakdown.

Shortcuts

Shortcut	Action
⌘⇧D	Switch to DIRECT
⌘K	Command palette (model switch, templates)

Tips

Spend premium only where it pays off

The savings-first ledger exists to make a real point: most stages don’t need your most expensive model. Put a cheap or local model on the planner and reviewer, reserve the premium model for the implementer, and let the ledger show how far under all-premium you landed.

Gate the plan, not the diff

A checkpoint before the implementer is usually worth more than one after it. Approving the plan up front prevents a long, expensive implementation stage from running in the wrong direction.

Note

Resume is for transient halts — a rate limit, a momentary provider hiccup — not for decisions. Use Approve / Reject / Send-back when the question is about the work itself.

Caution

Review loops are bounded on purpose. When a loop hits its iteration limit without converging, Octopush marks it exhausted rather than continuing — treat that as a signal to step in, not as a failure to retry blindly.