Skip to content
Orcho Docs

LLM captain mode

MCP can cost more tokens than a plain terminal run because the client may read status, evidence, events, diagnosis, and handoff state while the run is alive.

That cost only makes sense when the client is not a passive viewer. It must act as a lifecycle captain: keeping state, asking for the right evidence, explaining the next safe action, and helping the operator decide when Orcho pauses.

CLI is the strongest first perception surface.
MCP is the strongest captain surface.

What the captain does

Section titled “What the captain does”

As a captain, the client carries the lifecycle responsibilities a passive viewer skips:

  • know where the run lives and choose the operating shape;
  • start a bounded run and track its lifecycle;
  • read proof instead of guessing, and explain why a run stopped;
  • decide a pause with the operator, and ask for handoff advice;
  • continue from a meaningful checkpoint and inspect delivery state.

The typed MCP tools behind each of these are listed in MCP control surface.

The value is not “more automation”. The value is better control over work that would otherwise turn into a messy agent chat, a forgotten terminal log, or a manual reconstruction of what happened.

When the tokens are worth it

Section titled “When the tokens are worth it”

Use MCP captain mode when the task has real lifecycle risk:

  • plan or review can be rejected and needs human direction;
  • the run may pause on a declared handoff;
  • final acceptance can block delivery;
  • evidence and receipts matter more than a single final diff;
  • you need to recover, resume, or launch a correction follow-up later;
  • the user is already working inside a client that can call MCP tools.

In those cases, extra context calls can save larger costs: blind retries, wrong resumes, duplicated investigation, missed blockers, or a human having to read raw logs after the fact.

If accounting is enabled, compare this overhead with the actual run window instead of guessing. Cost accounting explains how to read API-equivalent workload, subscription value, and what-if pricing.

When not to use it

Section titled “When not to use it”

Do not make MCP the first choice for every task.

Use the CLI firstUse MCP captain mode
One small edit.Multi-phase delivery.
You mainly want the live stream.You need typed state and decisions.
No handoff or recovery expected.Rejections, pauses, or delivery gates matter.
Human is watching continuously.Client should help keep the run state.

For the simplest work, orcho run --output live is still the best first experience. MCP becomes valuable when the client can reduce operator load.

If there is no human-facing client at all, use CI autopilot instead. That path relies on --no-interactive and configured policy rather than an MCP client asking the operator for decisions.

The captain loop

Section titled “The captain loop”

The ordered loop — rehearse with mock=True, start the real run, observe typed state, decide explicit control points, and close with evidence and project checks — is the flagship workflow in Expert MCP control loop. This page is about whether to run that loop; that page is about how.

The boundary

Section titled “The boundary”

The LLM captain should not pretend to own the project: no scraping raw logs before typed status, no claiming delivery without evidence and project-level verification, no hiding token cost behind “agent magic”. The full anti-pattern list is in Expert MCP control loop.

The honest promise is narrower and stronger: MCP lets the client operate the Orcho lifecycle with state, decisions, and evidence.

Section titled “Related”