Pair a Strong Planner with a Low-Cost Executor

Using your most capable model for every step is simple, but it can be wasteful. Many workflows mix difficult decisions with routine execution. A planner–executor setup separates those jobs: one model decides what should happen, while another handles clearly defined tasks. Here is a practical way to start without building a complicated agent system.

#1 · Pick a small, testable job

Begin with something whose result you can check: updating a documentation page, adding input validation, or writing tests for one function. Avoid starting with a repository-wide rewrite or a production deployment.

Write down the desired outcome and its acceptance criteria. For example: “Reject empty usernames, preserve existing behavior for valid inputs, and add tests for both cases.” These criteria give both models a shared definition of done.

#2 · Choose models by role, not reputation

The planner needs to handle ambiguity, identify dependencies, and anticipate failure cases. The executor needs to follow bounded instructions reliably at a lower measured cost.

You might evaluate Claude Sonnet 5.5 as the planner and DeepSeek V4 Flash as the executor. Treat that as a candidate pairing, not a guaranteed ranking or price claim. Check current availability, pricing, context limits, and tool support, then test both models on your own workload. A cheaper request is not necessarily a cheaper completed task if it requires repeated repairs.

#3 · Ask the planner for an executable plan

Give the planner the user request, relevant files, constraints, and acceptance criteria. Ask it to identify missing information before proposing changes. Its output should be a short list of independent tasks where possible.

A useful instruction is: “For each task, specify the objective, required inputs, permitted changes, expected output, and verification steps. Flag assumptions and stop conditions. Do not implement the work yet.”

Keep the plan concrete. “Improve validation” is vague. “Add an empty-string check before the database call, preserve the existing error format, and add two regression tests” is actionable.

#4 · Hand off only the necessary context

Send the executor one task at a time, along with the relevant files and any shared constraints. Do not automatically forward the entire planning conversation. Smaller, focused handoffs can reduce token usage and make instructions easier to follow.

Include the task objective, allowed scope, acceptance checks, and escalation rule. For example: “If this requires changing the public interface or editing files outside this list, stop and explain why.” Keep credentials and unrelated sensitive data out of both prompts.

#5 · Execute inside clear boundaries

Let the executor produce a patch, draft, or structured result. If tools are involved, enforce permissions in your application rather than relying on prompt instructions alone. Use a sandbox where appropriate, limit writable paths, and require approval for destructive operations.

For a first implementation, a small script that makes a planner request followed by an executor request is enough. Relay365 fits naturally when you want to access multiple model families through a pay-as-you-go relay desk. Its API base is https://api.api365relay.com; OpenAI clients append /v1. Keep model identifiers configurable and verify supported request parameters before switching models.

#6 · Verify before asking for another opinion

Run deterministic checks first: tests, linting, schema validation, or a comparison against the acceptance criteria. Model review can complement these checks, but it should not replace them.

If verification fails, give the executor the specific failure and allow a limited repair attempt. Escalate architectural questions, contradictory requirements, or repeated failures to the planner. Set a retry limit and a spending cap so the workflow cannot loop indefinitely.

#7 · Measure, then expand

Record total cost, elapsed time, review effort, and whether the result passed your checks. Include planning and repair requests, not just the executor’s initial call. Compare the pairing against a single-model baseline on similar tasks.

If switching between model families is useful for your experiments, create a Relay365 account and try one small workflow first. Expand only when your measurements show a worthwhile tradeoff. The goal is not to use the cheapest model everywhere; it is to reserve expensive reasoning for decisions that actually need it.