Is a second model worth the extra time on dependency upgrades?

Tares lets you weigh it yourself: a challenger session adds 30 to 90 seconds per plan and one Codex review per commit, and in advisory mode findings never block. The Codex runs are billed to your OpenAI account, separate from your Claude usage. Start in advisory mode and move to strict only where a blocked commit is worth the wait.

How it works

In a challenger session, Claude Code plans and builds as usual while the OpenAI Codex CLI on your laptop critiques the work. Tares records the exchange and never calls Codex. The challenger is the same for any task. It treats dependency upgrades like any other work, so the cost is the general cost of the workflow.

The time and money come from three places:

• The plan. When Claude leaves plan mode, Codex critiques the plan in a read-only sandbox. It takes 30 to 90 seconds, so Claude’s first reply after you approve the plan is slower. A plan critique never blocks. Only a [P1] finding counts as blocking on a plan, and even then Claude is asked to revise or to tell you why it disagrees.
• Each commit. After every git commit, the plugin runs a Codex review of that commit. A dependency upgrade that lands as several commits gets a review per commit. Tares does not state a fixed time for a commit review. Every challenge_commit event carries a duration_seconds label, so you can read the real number for your repo from your first sessions.
• The second bill. Codex runs are billed by OpenAI to the account you logged in with. A session with a plan and three commits is typically five to eight Codex runs. The end-of-session summary is one Tares agent run, metered like every other agent run.

In the default strict mode, [P1] and [P2] findings on a commit block Claude until it fixes them and amends the commit. The amended commit is reviewed again as round 2, and so on. The loop is capped at 8 rounds per commit and 5 turn ends per session. [P3] findings, Codex timeouts, errors and inconclusive reviews never block.

Set it up

1. Run Tares with its MCP endpoint next to it. On Tares Cloud the instance serves the endpoint itself.

tares up
tares mcp --transport streamable-http

2. Install the Tares plugin for Claude Code, version 0.2 or later, with the two /plugin commands from the challenger workflow guide. On a secured instance, give the install a read + ingest API key.
3. Install the Codex CLI and log in with codex login. This is the account that receives the second bill.
4. Set the plugin option challenger_mode to advise. Commit findings then arrive as context and never block, so the only added wait is the review itself.
5. In Claude Code, say “make this a challenger session” before you start the upgrade. The first marked session creates the Challenger workflow project on Tares by itself.
6. Run the upgrade, then open the project’s Sessions list. Check duration_seconds on the challenge_plan and challenge_commit events, and compare the findings with the time they cost.
7. If strict mode is on and you disagree with a blocking finding, use /tares:challenger-waive to waive it. To drop the challenger for the rest of a session, use /tares:challenger off.

What you get

• A critique of the plan before Claude starts building, tagged [P1], [P2] or [P3], in 30 to 90 seconds.
• A review of every commit by a second model, with the verdict (PASS, FAIL, INCONCLUSIVE, TIMEOUT or ERROR), the finding count and the duration recorded on the session timeline.
• One thread per session on Tares that shows the Claude and Codex exchange, with a badge per reviewed commit (Findings (N) or Pass).
• A summary written by the challenger_summarizer agent when the session ends. It covers what was built, what Codex caught, cost and up to five Memory proposals. Nothing reaches memory until you accept it.
• Control over cost. Reviews run on your laptop, so a slow or down Tares never blocks one. The review history stays under the repository’s .git/.

When something else fits

• Advisory mode is enough when you want a second opinion without any blocked commits. Findings still land on the timeline, and you decide what to act on. Strict mode fits changes where an unreviewed mistake costs more than the extra rounds, and the 8-round cap bounds the wait.
• If the second OpenAI bill or the per-commit wait outweighs the benefit for a routine upgrade, leave the session unmarked. An unmarked session is streamed like any other and no Codex run happens.
• To see how this fits the wider software factory for Claude Code, read Get started.

Related