Let your agent drive it

The other front door

There are two ways into Orcho. The CLI is you at the wheel: you run it, you watch the live output. MCP is the lighter way: you hand the wheel to the AI client you already use — it starts runs, reads state and evidence, and tells you the next safe move — while you stay the one who decides.

Drive it yourself (CLI)Set up MCP

same run, either wayCLI to see itMCP to steer it

your client’s first calla safe dry run

orcho_run_start(
project_dir="/abs/path/to/project",
task="Add validation to the login endpoint.",
profile="feature",
mock=True,
)

With mock=True the client rehearses the whole lifecycle without editing your code or spending provider tokens. It is the safest way to let your agent learn the wheel.

01Two doorsCLI to watch a run, MCP to let your client operate it.02Why it feels lighterNo flags to learn — you ask, the client drives.03You still decideThe client steers with typed state; you approve the moves.04Where to goPick the CLI quickstart or the full MCP setup.

Two front doors

The same run can be reached two ways.

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

The CLI is the basis: you type a command and the live stream shows you the run as it happens. It is the clearest way to actually see what Orcho does. MCP sits on top of that same machinery — it lets a client that speaks the Model Context Protocol call Orcho’s typed tools instead of you typing commands.

You drive — CLIYou run orcho run and watch the live output. Best for seeing a run clearly for the first time.Your agent drives — MCPYour AI client starts the run and reads its state for you. Best when you already work inside that client.

Why MCP feels lighter

If you already live inside Claude, an IDE assistant, or another MCP-aware client, MCP is often the lower-friction start. You do not learn command flags. You describe the task, and the client becomes a captain for the run: it starts it, tracks the lifecycle, pulls the right evidence, and explains the next safe action.

Be clear about what that lightness is and is not:

• it is not more “magic” — it is the same run, the same gates, the same evidence;
• the difference is who holds the wheel: you supervise instead of typing every command;
• the run stays just as inspectable, because the client reads typed state and evidence rather than guessing from a chat.

LLM captain mode explains when this is worth the extra tokens, and when the plain CLI is still the better first choice.

You still hold the wheel

Handing the wheel to a captain is not the same as letting go.

• The client reads typed status and evidence, not scraped logs, so it is not guessing.
• When Orcho pauses, it surfaces a typed handoff with the allowed actions — the client shows you the decision instead of inventing one.
• You still verify the delivered code with your own project tools (git diff, your tests) before calling the work done.

One honest limit: MCP keeps Orcho’s control local, but it does not make a third-party worker runtime local. Prompts and selected source context can still reach the provider. Security and privacy traces exactly what crosses that boundary.

Where to go next

Run the CLI quickstartThe most observable first look: one command, live output.Set up MCPConnect a client, run a safe mock pass, then a real run.Understand captain modeWhen letting the client drive is worth it — and when it isn’t.Open the docs mapPick your next layer when you want more depth.