Getting more out of your LLM subscriptions

The models never see each other's work. That is the waste. And the fix is not a better model. It is a better division of labor.

The waste nobody talks about.

Each subscription is a specialist you keep asking to do everything. Opus is a brilliant planner, so you also make it write the code. Codex is sharp on code, so you also make it think through strategy. You get competent work from every model and great work from none, because none of them is doing the one thing it is best at.

Run them as a team and the math changes. One model plans. Another reviews the plan. Cheaper, faster models execute it. Same subscriptions, a fraction of the effort, noticeably better output. Here is the loop.

The loop: plan, review, execute.

Three roles, one goal. Every real task moves through the same three hands. The trick is that each hand is a different model, chosen for what it is best at.

Plan

Opus high / max

Review

Codex 5.6 xhigh

Execute

Sonnet · Kimi k3 · Codex

Plan

Opus · high / max

The best thinker gets the goal and constraints, and returns a plan. Not code. Steps, risks, order.

Review

Codex 5.6 · xhigh / high

A different model tries to break the plan. It catches the missing step and the wrong assumption the planner cannot see.

Execute

Sonnet high · Kimi k3 · Codex

The plan is reviewed and boring to run. Route each task to the cheapest model that does it well.

Plan with Opus, reasoning turned up.

Start with the model that thinks best. Give Opus the goal, the constraints, and what "done" looks like, then ask for a plan, not code. Turn its reasoning up: high for most work, max for the gnarly, high-stakes tasks where a missed edge case is expensive. You want the steps, the risks, the order, and the things that could go wrong. Planning is a small slice of total token spend, so this is the cheapest place to buy quality.

Review with Codex 5.6, told to break it.

Hand that plan to a different model and ask it to poke holes. Codex 5.6 at xhigh is a ruthless reviewer. It catches the missing step, the wrong assumption, and the edge case the planner glossed over. A model reviewing its own plan is graded by the same blind spots that wrote it. A second model reviewing the first is the whole trick. You get most of the value of a senior review, for cents.

Execute with whatever is cheapest and good enough.

Now the plan is boring to run, which is exactly what you want. Route each task to the cheapest model that can do it well. Sonnet high for balanced build work. Kimi k3 when there is a lot of it and cost matters. Codex agents for code that has to compile. The hard thinking is already done and reviewed. Execution is just following the map.

Running it in GitHub.

If you already work out of a repo, the repo is the handoff. Opus writes the plan into a doc or an issue. Codex reviews it right there, in a comment or a pull request. Your executor agents pick up tasks and push commits. Each one starts where the last stopped, because the repo is the shared memory none of them have on their own.

Write the convention down once, in an AGENTS.md or a handoff doc, and the models pass work to each other without you in the middle. You stop being the courier and start being the editor.

# AGENTS.md  (the shared rules)

Planner   -> Opus high. Writes /docs/plans/<task>.md. No code.
Reviewer  -> Codex 5.6 xhigh. Reviews the plan in the PR. Approves or sends back.
Executors -> Sonnet high, Kimi k3, Codex. Pick up an approved plan,
             open a branch, push commits, link the plan.

Handoff rule: never start work that isn't reviewed. Leave the next
agent a one-line note in the PR describing where you stopped.

A handoff doc the agents read before they touch anything. Illustrative.

Running it in chat.

No repo? The loop still works. You are just the wire. Paste your Opus plan into a Codex chat and ask it to review. Paste the reviewed plan into a Sonnet or Kimi chat and ask it to execute. The context travels in your clipboard instead of a repo.

It is slower and more manual, but it needs nothing beyond the subscriptions you already pay for. Most people should start right here, today, before automating a single thing.

Opus (high)      ->  "Here's the goal. Give me a plan, not code."
                       copy the plan
Codex 5.6 (xhigh) -> "Break this plan. What's missing or wrong?"
                       copy the tightened plan
Sonnet / Kimi k3  -> "Execute step 1. Here's the reviewed plan."

The same loop, done by hand across three tabs.

The orchestrator: your own Jarvis.

I take this further, because I have to. I run a lot of initiatives at once, across client work and my own companies, and routing every task by hand does not scale. So I don't. I run an orchestrator on Kimi 3 Max that reads each task and calls the model best suited to it: Opus to plan, Codex to review, Kimi and Codex agents to execute. I talk to one thing. It runs the team behind the curtain.

Orchestrator

Kimi 3 Max

reads the task, calls the right model

Plan

Opus

Review

Codex 5.6

Execute

Kimi k3 · Codex

You talk to one thing. It runs the team behind the curtain.

That orchestrator is the foundation of my personal Jarvis. One inbox, many models, each doing what it is best at, work moving between them while I am doing something else. You do not need this on day one. But once plan, review, execute is second nature, an orchestrator is the natural next step. It is where this stops feeling like a workflow and starts feeling like an assistant.

FAQ

Short answers.

Do I need all of these subscriptions?

No. Start with two: one strong planner and one executor. Add a reviewer and a cheap volume model when the workflow earns it. The loop matters more than the roster.

Why not just use one model for everything?

One model planning and then grading its own plan is blind to the same things twice. A second model reviewing the first catches them in one pass. The second pair of eyes is the whole point, and it costs cents.

Opus high or Opus max?

High for most plans. Save max for the gnarly, high-stakes tasks where a missed edge case is expensive to unwind. Planning is a small slice of total spend, so buying quality here is cheap.

GitHub or chat?

Repo if you want the models to hand off without you sitting in the middle. Chat if you want the workflow today with zero setup. Same loop either way. Most people should start in chat and graduate to a repo.

What exactly is Michael?

The whole stack on your own server: the models, the orchestrator, and the handoff plumbing, pre-wired. One plan, $49 a month, instead of hundreds spread across separate subscriptions. The fastest way from reading this guide to running it.

Free · 9 min read

Read the rest of the guide.

The full loop, the GitHub and chat setups, the orchestrator that runs my own Jarvis, and the diagrams. Drop your email and it opens.

No spam. A short sequence on running models as a team, then quiet. Unsubscribe anytime.

Getting more out of your LLM subscriptions.

The waste nobody talks about.

The loop: plan, review, execute.

Read the rest of the guide.