Paired & Entrusted Modes

Michi has two modes of practice. They’re not levels to graduate through — they’re tools to select based on context.

Paired (lights on)

Human and agent work in a tight loop. You’re present, engaged, driving decisions. The agent takes smaller steps and checks in more often.

This isn’t a slower version of the alternative. Paired mode is where the human contributes things the agent structurally can’t: design taste, domain context about how users actually behave, willingness to challenge “good enough.”

In building a Playwright trace tool, key human interventions during Paired sessions included suggesting real-app testing (which exposed a major gap), recognizing a judgment issue the agent was over-engineering (“this is a judgment issue — let the agent interpret”), and applying “separate what from how” to improve the architecture during a sustainability check. None of these could have come from the agent alone.

Pace calibration

Start slow. In one session, the agent came in hot — ready to tackle everything at once. The human pulled it back: “only take the single smallest next step.” By milestone four, the agent had absorbed the human’s approach well enough to propose dropping an unnecessary abstraction before being asked. Long sessions preserve the spirit of the collaboration; each milestone teaches the agent your preferences.

Like a new pair programming partner — the first 30 minutes establish working style. Don’t try to instantly accelerate.

Entrusted (running dark)

The agent has wider initiative within established scope. You review at gates and exceptions, not every step. The agent makes judgment calls and logs them. Decision logs and verification infrastructure see for you.

This mode is earned through demonstrated mastery — of the tools, the codebase, and the verification discipline. Specifically:

• The agent produces correct code reliably
• Decisions are well-documented and reasonable when reviewed
• Verification steps are followed, not skipped
• Cross-package impacts are caught, not missed

When to use which

The first epic is always Paired. The Michi context that makes wider autonomy viable — journals, learnings, scenario catalogs, architecture docs — doesn’t exist yet. The starting spec is a hypothesis: it may reference tools that don’t exist or make assumptions that haven’t been validated. Paired mode is how you and the agent build shared context about both the project and the Michi process.

Move to Entrusted when verification catches enough. If your test suite, scenarios, and review process consistently catch issues before they escape, the agent has earned more rope. The key metric isn’t “does the agent write good code?” — it’s “does our verification catch it when it doesn’t?”

Move back to Paired when needed. New codebase, risky work, unfamiliar domain, lost confidence — slow down. This isn’t regression. It’s knowing when you need visibility.

In one project analyzing a personal knowledge base, the agent confidently assessed a “finishing gap” — claiming the human tends not to finish projects. The human corrected with context the agent couldn’t see: hundreds of published photographs, shipped products, and completed work that simply weren’t in the documents the agent had read. The agent’s analysis was internally consistent but built on wrong premises. That’s exactly the situation where Paired mode is essential — the agent can’t know what it can’t see.

Pacing follows from Complexity and Uncertainty

Mode (Paired or Entrusted) is one axis. The other is the work’s Complexity and Uncertainty — where it sits on a second dimension:

Complexity factors — codebase characteristics: greenfield vs. brownfield vs. legacy, repo size, tightness of existing constraints, depth and rigidity of dependencies.

Uncertainty factors — knowledge characteristics: novel vs. commodity domain, requirements clarity (well-defined vs. discovered through the work), test coverage, prior agent exposure to this codebase, novel pattern or new territory.

The two combine into a Low / Mixed / High reading, which shapes pacing within each mode (Crawl → Walk → Run → Fly):

• Low Complexity/Uncertainty — pacing is your choice. Entrusted at any pace is defensible.
• Mixed (Low on one axis, High on the other) — be careful. You may not need the full baby steps of High C/U, but don’t start running at the outset.
• High Complexity/Uncertainty — start in Paired with Crawl/Walk. Entrusted is earned by demonstrating alignment over the first one or two milestones. Brownfield with tight conventions, first epic in an unfamiliar codebase, and novel pattern application are all High signals.

The first epic in any codebase is implicitly High Complexity/Uncertainty — shared context doesn’t yet exist, agent exposure is none, and conventions (if any) are unread. The first-epic rule (“always Paired”) follows naturally from where first epics sit on the grid.

The metaphor

A michi runs with the lights off. Paired is lights-on — you need to see the agent’s work directly. Entrusted is running dark — verification infrastructure, decision logs, and scenario discipline see for you.

The project is about earning the right to turn the lights off. And knowing when to turn them back on.