Shift Log: Planner–Executor Split Under Review

The proposed change for this shift is straightforward: let a strong model decide what should happen, then hand bounded implementation work to a cheaper model. The competing setup keeps planning, execution, and corrections inside one strong model. The split promises lower spending, but every handoff creates another place for intent to drift.

This is an architectural comparison, not a measured model benchmark. For a pilot, Claude Opus 5.5 could occupy the planner slot and DeepSeek V4 Flash the executor slot, provided your own evaluations and current prices support those assignments. Model names alone do not establish reasoning quality, execution reliability, or savings.

The handoff contract decides whether the split works

A useful planner does more than produce a checklist. It defines the objective, relevant context, permitted changes, acceptance tests, and conditions that require escalation. The executor receives enough information to complete one bounded task without reconstructing the entire project history.

For a repository change, that contract might identify the target function, describe the expected behavior, prohibit public interface changes, and specify the tests to run. If an assumption proves false, the executor should return evidence rather than silently invent a replacement plan.

The planner should own ambiguity; the executor should own bounded implementation. If both models repeatedly reinterpret the requirements, you are paying for two overlapping reasoning loops rather than dividing the work.

Cost favors the split only after retries are counted

The single-model setup has a simple cost profile: one model handles the full task and its corrections. The split adds a planning call, handoff context, executor calls, validation, and possible escalation. A lower executor token rate does not automatically produce a lower completed-task cost.

The split becomes attractive when one plan supports substantial execution: similar transformations across files, repeated structured extraction, or several independent patches with clear tests. It is less attractive for a short request where planning and handoff consume most of the work.

Cost verdict: Favor the split for repeatable execution with low correction rates. Favor one strong model for small tasks or work that frequently returns to the planner. Compare total cost per accepted result, including failed attempts.

Quality depends on evidence, not planner authority

A strong plan can still be wrong, and a cheaper executor can follow a wrong plan perfectly. Conversely, a correct plan can lose critical detail during handoff. The single-model approach avoids that boundary, although it can still make implementation errors.

Use checks outside either model wherever possible: tests, schema validation, static analysis, sandboxed execution, and human review for consequential changes. When independent checks are incomplete, planner review can help, but it is not independent proof of correctness.

Quality verdict: Use the split when acceptance criteria are observable. Keep tightly coupled reasoning and implementation together when correctness depends on subtle context that cannot be packaged reliably.

Latency and incident handling expose the coordination tax

Sequential planning, execution, and review add waiting time. Parallel execution can offset that cost when tasks are genuinely independent, but shared files, dependencies, and merge conflicts can erase the gain. Measure end-to-end completion time, not just executor response speed.

Operationally, one model means fewer routing rules and fewer handoff records. A split needs explicit retry limits, tool permissions, escalation triggers, and traces connecting each action to its plan. Treat executor output as untrusted input before allowing deployment or destructive operations.

Operations verdict: Keep the single-model path for urgent, ambiguous incidents. Introduce the split first in controlled queues where failures are reversible and validation is routine.

Relay365 fits the routing experiment, not the verdict

Relay365 is a pay-as-you-go relay desk for multiple model families, making it a practical option for testing planner and executor choices through a common access point. It works with Claude Code, Codex, Gemini CLI, and OpenAI SDK clients. Its API base is https://api.api365relay.com; OpenAI clients append /v1. Check model availability, pricing, tool support, and data-handling requirements before rollout.

Create a Relay365 account if that shared access fits your evaluation workflow. Start with a representative task set and record acceptance rate, total spend, elapsed time, and escalation frequency.

The shift verdict is selective adoption

Approve the planner–executor split for bounded, testable work with enough execution volume to justify coordination. Retain one strong model for short, ambiguous, or tightly coupled tasks. The winning architecture is the one that delivers accepted work at a lower operational cost—not the one with the cheapest executor call.