TL;DR: Choosing an AI model has become a job of its own. Cheap models can handle a growing share of everyday work, while complex workflows still need stronger and more expensive intelligence. Most people solve this by using a premium model for everything. Conductor Mode makes the choice automatically, and its model assignments can change as better options become available.

Most users do not know which AI model is right for the job.

They try a cheaper model, hit its limits on a complex task, get frustrated, and switch to a premium model. Then they leave the premium model selected for everything, including the routine work that a much less expensive model could handle just as well.

That choice used to be simpler. When only a small number of models were genuinely capable, using the best available model for every request was reasonable. The quality gap was obvious, and there were fewer serious options to compare.

The market now looks completely different. Capable models span a widening range from low-cost reasoning models to ultra-high-cost frontier systems. They vary across reasoning, coding, tool use, speed, context, multimodal input, and structured output. More models arrive constantly, and small language models will make the landscape even more fragmented.

This creates a growing allocation problem for every AI product and agent: which model should handle this specific piece of work?

Expecting users to answer that question on every turn does not scale. Most will either overpay for routine tasks or accept unreliable results when the workflow becomes more demanding.

Conductor Mode solves the allocation problem automatically. It evaluates the structure of each task and routes it to the least expensive model equipped to complete it reliably.

The decision does not depend on topic, prompt length, or how technical the request sounds. A dense math problem may need one clean reasoning pass. A two-word reply such as “do it” may continue a workflow involving external data, tool calls, and irreversible actions. The structure of the work is what matters.

How Conductor Mode works

Every time you ask your agent to do something, Conductor Mode asks two simple questions.

1. Does the agent need to complete multiple steps in a specific order?

Some tasks can be answered immediately. Others require the agent to complete one step before it can begin the next.

For example, if you ask, “What is Bitcoin’s price right now, and how has it changed this week?”, the agent must first fetch the current price and historical data. Only then can it calculate the change and answer you.

Research works the same way. The agent may need to search, read several sources, compare what it finds, and then reach a conclusion. Each step depends on the result before it.

This also applies when the agent must read a file, check an account balance, query an API, run code, or verify that an action succeeded.

If the answer depends on information or work the agent must complete first, Conductor Mode sends the task to the strong model.

2. Does the answer need to follow exact instructions so another system can use it?

Sometimes an answer can be useful even if the wording or layout varies. At other times, “almost right” means the task fails.

A tool call must contain the correct fields. Data sent to another application must follow the expected format. Code may need to pass a test. A report may need specific sections that another workflow relies on.

If the result must follow an exact structure or set of instructions, Conductor Mode sends the task to the strong model.

If the answer to both questions is no, the task goes to the low-cost reasoning model. This covers self-contained work such as explanations, brainstorming, rewriting, and many math or coding questions.

What happens when the strong model still needs help?

There are three levels, not two:

1. Low-cost reasoning: handles self-contained everyday work.
2. Strong: handles multi-step work, live data, tools, and exact output requirements.
3. Escalation: a stronger model takes over when a task needs more capability or the strong route cannot complete it reliably.

Conductor Mode chooses between the first two levels at the start. The third is a safety net for the difficult cases. The specific model assigned to each level is reviewed and updated as the available models change, so the routing policy stays current without changing how the workflow decision works.

Images and other multimodal requests use a separate media route with a model designed for visual input.

Topic, prompt length, and how technical a request sounds do not make this decision. The structure of the work does.

Why single-pass math and code can stay cheap

The economy leg is assigned to a cost-efficient reasoning model. The exact model can change as new options are evaluated.

Its role matters because “cheap” no longer means “incapable of reasoning.” A capable reasoning model allows single-pass math, code, analysis, explanations, and other self-contained tasks to remain cost-efficient.

Consider two requests:

• “Explain why this sorting function is O(n log n).”
• “Inspect this repository, find the performance regression, modify the implementation, run the tests, and return the patch in the required format.”

Both concern code. Their workflow structures are completely different.

The first request can be answered directly. The second requires several steps in order, plus an exact deliverable at the end. Conductor Mode routes them accordingly instead of sending both to the same model because they share a topic.

This is the central idea behind cost-aware model routing: spend more intelligence when the workflow needs it, while keeping capable everyday reasoning inexpensive.

The benchmark: four suites, objective scoring

The latest Conductor V3 report compares multi-model routing against single models and frontier baselines on a mixed-150 public set. The equal-weight composite covers four suites: AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks. Cost is the mean dollars per task across those four suites, and only models that completed all four are included in the composite ranking.

The benchmark report records one model assignment at a particular point in time: DeepSeek V4 Flash for economy work, GPT-5.6 Luna at xhigh for strong work, and Qwen 3.8 Max for escalation. Images routed to Luna, video routed to Qwen 3.8 Max, and the fallback path was Luna → Qwen 3.8 Max → DeepSeek V4 Flash. These assignments are examples from that benchmark snapshot, not permanent product dependencies. Conductor Mode reviews them regularly and can replace them as model quality, pricing, and availability change.

The report also notes that Conductor V2 is excluded from the four-suite composite because it never ran the GPQA or LiveCodeBench pools. This keeps the comparison aligned to measured runs rather than mixing incomplete result sets.

Cost versus quality across the four-suite benchmark. Conductor Mode V3 sits near the efficient frontier, combining high measured accuracy with lower average cost per task.

Read the full Conductor Mode benchmark report.

What changed from Conductor Mode V2

Earlier versions used a simpler system for deciding which model should handle a request. Conductor Mode V2 improved this by testing models on real agent tasks and choosing them based on the results. This update keeps that testing process, while making the routing itself smarter and more reliable.

• Better task matching: requests involving several connected steps or an exact required format are sent to a stronger model.
• Lower-cost reasoning: the current economy model handles self-contained work, including many math and coding questions, without automatically using a more expensive model.
• Extra help for difficult tasks: if the first model cannot complete the job reliably, the current escalation model can take over.
• Fewer failed requests: if the first routing decision fails, Conductor Mode tries again and has backup models ready.
• Smarter follow-up handling: short replies such as “do it” are understood as part of the task already in progress.
• Better handling for images: requests involving visual content are sent to a model designed for that type of input.
• Easier to improve over time: the routing rules can be updated as models improve, without rebuilding the entire agent system.

Explore the technical overview, or create a Starchild agent and let Conductor Mode choose the right model for the work.

Frequently asked questions

How does Conductor Mode choose a model?

Conductor Mode checks whether the request requires multiple steps in a specific order or an answer that must follow exact instructions. Either condition sends the task to the strong model. If neither applies, the task uses the low-cost reasoning model. A third escalation level handles the most difficult cases. The models assigned to these levels are updated regularly, so the names in any benchmark report should be read as a dated snapshot.

Does technical content always use the strong leg?

No. Topic, prompt length, and technical tone are ignored. A self-contained coding or math request can remain on the low-cost reasoning model if it does not require several connected steps, fetched data, tools, or an exact output format.

Why does fetched data use stronger handling?

The agent must retrieve the information before it can form the answer. Sending these tasks to the strong model reduces the risk of inventing missing facts and improves how the agent handles the retrieved data.

How does Conductor Mode reduce AI agent costs?

It uses a cost-efficient reasoning model for self-contained work and reserves stronger models for tasks involving multiple connected steps or exact output requirements. The escalation model is used only when needed.

How was Conductor Mode benchmarked?

Each model ran the full agent loop with real tools. Results were scored through objective exact-match, with code evaluated on the same grading harness. The benchmark used no LLM judge.

What result did Conductor Mode achieve?

The latest report measures an equal-weight composite across AIME 2025, GPQA Diamond, LiveCodeBench 100, and Everyday tasks. Its headline LiveCodeBench result for the V3 ladder is 90%+ on the 99-problem same-set pool at about $0.02 per problem. These figures describe that benchmark run, while the live model assignments may change as the system is updated.