A couple of weeks ago I tweeted that I was tired of being the integration layer between my own Codex threads. The reviewer runs. I wait. I read the findings, paste them into the worker, and we do it all again.

The obvious fix is to automate the loop: an orchestrator spawns the worker, spawns the reviewer, and routes the findings between them. I built that. Then I hit a problem I didn’t expect: the loop would run fine, and just never finish.

You’d think the failure mode is that the reviewer keeps finding bugs. It isn’t. That’s the loop working. The failure mode is that each round makes the work bigger instead of more finished. The reviewer reports one symptom per round and never names the missing decision underneath. The worker answers a design problem with a local patch, and the patch breeds a new family of findings. I once watched one missing invariant, shared by eight call sites, get “fixed” eight separate times. It should have been repaired once, in the plan.

Convergo is that loop with convergence rules built in. Three rules do most of the work.

First, feedback goes through intake before anything gets edited. The worker classifies each finding. A code bug, it fixes. A missing decision, it brings back to you instead of patching around the hole. And a bug that could repeat, it treats as a pattern: audit the adjacent surfaces, fix every instance, report what was checked. One reviewer finding becomes one sweep, not the first of eight identical rounds.

Second, the exit is guarded by a fresh reviewer: a newly spawned session that reads the plan and the diff cold, with no memory of the earlier rounds. The reviewer who spent three rounds arguing with the worker never gets to declare victory.

Third, the loop is capped. Three rounds without a clean fresh pass, and it stops and hands you the open findings instead of churning.

That’s the loop. The rest of this post is about a question that appeared the moment it worked: which model should play which role?

Fable is rationed. Codex isn’t.

Here’s my situation, and probably yours. Fable has the best judgment I can get, and it’s rationed. It’s in my subscription for exactly one week, at half limits, and after that it’s API pricing only. GPT-5.5 at xhigh effort through the Codex CLI is nearly as capable at execution, and with the resets most of us have stacked, it’s effectively unmetered.

So the judgment is rationed, the iteration is free, and a review loop needs a lot of both. Burning Fable turns on “run the tests again” wastes the only budget that’s actually finite. The hybrid preset is the routing that takes this seriously:

Role Engine
Planner, plan revisions Fable
Plan reviewers Codex (gpt-5.5 xhigh)
Worker, first-pass code reviews, QA Codex (gpt-5.5 xhigh)
The final exit gate Fable

Row by row: planning sets direction, and direction is where judgment pays most. Checking a plan against the real codebase is execution work, so Codex does it. There’s a bonus here: a second model family reviewing the plan catches blind spots that self-review shares. Implementation and the review grind is where the tokens actually burn, so all of it lands on the engine with stacked resets. And the one review that decides whether the thing ships goes to the model I trust most.

The tiered exit

My favorite mechanism is the exit. Nobody knows in advance which review round is the last one. So in the hybrid loop, a clean Codex review never ends the loop. It promotes. A clean pass from the cheap engine summons a Fable fresh review, and only a clean Fable pass ships. If Fable finds blockers, the worker fixes them, Fable re-checks, and the next round starts back at the Codex tier.

The effect: Fable runs once or twice per loop, exactly at the moments the cheap engine believes the work is done.

One practical note. The Codex specialists run sandboxed: workers can write only inside their own worktree, reviewers get the repo read-only at the OS level, and every session resume re-pins the sandbox so it can’t quietly escalate. The details live in the repo’s eval suites.

What it costs, and when not to use it

A build-loop run costs about ten times the tokens of telling an agent to just implement it. I want to be straight about that. The multiplier is the product: independent review, fresh eyes every round, a bounded number of rounds. It’s the same thing you pay for when a second person reviews your PR.

So no, this is not how I write most code. Spikes, prototypes, UI iteration: I drive the agent directly, like everyone else.

Some changes deserve more. The auth change. The migration. Code that touches money or user data. The PR you’d want reviewed twice if you had teammates. For those, Convergo is an option: run the loop, let the two models take turns, and ship what a fresh reviewer with taste signed off on.

Try it

One prerequisite worth knowing up front: the hybrid presets need Convergo installed on both sides, the Claude Code plugin and the Codex plugin, because the Codex specialists load their role skills by name. If either side is missing, the loop stops with a blocker instead of quietly degrading to one engine.

# Claude Code
/plugin marketplace add gomilesf/convergo
/plugin install convergo

# Codex CLI
codex plugin marketplace add gomilesf/convergo
codex   # /plugins -> Convergo -> install, then restart

Then, on a real issue:

/cvg-hybrid-plan-loop docs/briefs/your-topic.md
... review the plan yourself ...
/cvg-hybrid-build-loop docs/plans/your-topic-plan.md

Convergo also runs on Codex, Cursor, OpenCode, Pi, and Gemini CLI with the base skills. The hybrid presets are Claude Code-only for now. It started as a convergence-focused fork of Every Inc’s Compound Engineering plugin: they got the plan-first shape right, and Convergo makes the loops terminate.

Repo: https://github.com/gomilesf/convergo

If you try it on something real, tell me where it fought you. The loop knowing when to give up is the feature.