For a long time, the AI race looked simple: every lab tried to build the biggest, most expensive and most powerful model on the market. But when we take these models into real-world situations, we hit a problem. Too often we are using a tool far more powerful than the task requires: summarizing a note, pulling a date out of a document, writing a first draft, or making a repetitive change in a code file.
That is why the shift of recent months is not only about building ever more advanced language models. It is about building systems that can decide, at each step, which model, agent or tool to use, and when it is better to stop, check the results or ask a human for help.
Andrew Ng, one of the best-known voices in the field, has long pointed to four core patterns of so-called agentic workflows: reflection, tool use, planning and multi-agent collaboration. All four share one idea: the model no longer has to give a definitive answer in a single attempt.
Where this comes from
This article continues a line of thought I started at Codemotion. The first piece, on task switching, argued that for most everyday tasks we don’t need the newest model every time. Organizing your tools in tiers, from frontier models down to free local ones, lets you pick the right option for each job instead of chasing every new release.
More recently, on my own site, I published a second piece on how Opus 5 overtook Fable 5. There the theory started showing up in the data: faced with a pricier top-tier model with certain limitations, companies began moving part of their spending to cheaper alternatives, reserving the most powerful models for the tasks that truly need them.
The next question is what happens when we don’t switch models just once at the start of a conversation, but build a system that distributes the work across the whole process. In other words, a system that automatically assigns different roles to different models and tools, without a person picking from a dropdown menu each time.
What “switching” really means
The word covers four levels of increasing sophistication.
- Model selection. The simplest form: choosing the most suitable model before processing a request at all.
- Routing. The system uses information about the request, its domain, its risk level or its expected cost to decide which path each task follows.
- Cascading. The system first tries to solve the problem with a cheap model and escalates to a more powerful one only if the result isn’t good enough.
- Delegation. With agents, the task is split into parts and assigned to different roles, which may have different models, tools and permissions.
A practical example: a customer-service question about the status of a shipment can be answered in seconds by a cheap model. A claim involving a large refund or a possible legal issue needs a stronger model, access to extra documentation and, most likely, human review before the case is closed.
From a single model to a system of parts
A single model is like one exceptional professional we ask to handle absolutely everything, from the dullest admin work to the most complex diagnoses.
An orchestrated system looks more like a newsroom or a development team. Each task goes to whoever can best handle it, taking into account their knowledge, cost, available tools and the level of responsibility involved.
It is worth being clear about one thing: this doesn’t necessarily mean we are building a “smarter” AI if we look only at the language model. We may simply be building a more efficient system that makes better use of the resources it has.
A small, fast model can select information, extract data, classify content and prepare first drafts. A state-of-the-art model steps in only when it’s time to plan, resolve ambiguity, make important decisions or do a final review. And we can add external tools that aren’t language models at all: ordinary programs that check data, run tests or query databases with a precision no LLM can guarantee on its own.
Routing, cascading and delegation
The router
The router is, in a way, the system’s receptionist. It receives a request and works out what kind it is and how hard. Is it short or long? Does it need general knowledge or deeper reasoning? Is the risk low or high? Does it need external tools?
To decide, it can use hand-written rules, a dedicated classifier, another language model acting as arbiter, or a trained system that estimates the quality-versus-cost trade-off of each available model.
But the router can be wrong. If it underestimates a task, it may send it to a model that isn’t up to it and produce poor output. If it plays safe and treats everything as complex, everything lands on the most expensive model and the economic advantage disappears. At that point the system has no reason to exist.
The cascade
Cascading works differently. In classic routing, the decision comes before any answer is generated: “this question goes to model A.” In a cascade, a cheap model answers first and then the system checks whether that answer is good enough. If it isn’t, it gets corrected, regenerated, sent to a reviewer or passed up to a more expensive model.
The main challenge is measuring answer quality. The system can use confidence scores, dedicated evaluators, automated tests, comparisons across multiple answers or a second model acting as judge. That judge can be wrong too: it may share the biases of the model that wrote the answer, or reward a convincing answer over a correct one.
Delegation
A step further is to break the problem into separate tasks. Most real-world work doesn’t have a single answer. It is a chain of actions: understand the goal, find sources, read documents, compare options, run calculations or code, check requirements, prepare a result and finally review it.
A planner agent can draft a plan with all those subtasks and assign each to the right worker:
- Information search: an agent with browser or database access.
- Calculations and numerical work: a Python environment.
- Repetitive drafting: a fast model.
- Harder reasoning: a more powerful model.
- Final approval: a person.
Still, splitting a task isn’t always better. If the work can’t really be divided into independent parts, fragmenting it can lose information, add unnecessary steps and make it harder to find where an error occurred.
Anthropic documents several of these patterns in its guide “Building effective agents.” It describes the orchestrator-workers pattern as a central model that dynamically breaks down a task, delegates the pieces to other models and combines the results into a final answer. This is especially useful when you can’t know in advance which subtasks will be needed, as in coding projects that touch many files.
The last level is true multi-agent orchestration. Here we are no longer just choosing models; we are organizing the whole process: roles, order of actions, available tools, shared memory, controls, permissions, error handling, stopping conditions and who ultimately takes responsibility if something goes wrong.
A case study: Astra Flash Orchestrator
A concrete example helps. The repository astra-flash-orchestrator, published by developer Ethan+ (who also made other agent-related projects, such as the Jarvis voice assistant for Claude Code), is designed as a native workflow for Codex, OpenAI’s agent-based coding environment.
The idea is that Astra handles planning, architecture and final review, while DeepSeek V4.1 Flash, a much cheaper model, takes on implementation, testing and routine debugging.
As its creator explains in a public discussion on the Codex repository, it works like this. Given a complex goal, Astra interprets the request, defines its scope and sets the criteria the result must meet. DeepSeek Flash then implements it: it reads the existing code, writes the changes, runs the tests and fixes the usual problems that come up. Finally, Astra reviews the changes, checks that everything fits the original plan, and decides whether to accept the work or send it back for another round.
The process has several phases:
- Planning and task splitting: Astra analyzes the goal and breaks it into smaller parts.
- Delegation: the tasks go to a cheaper model that does the hands-on work.
- Automated checks: tests provide external evidence about the result, which is more reliable than asking the model whether it did a good job.
- Correction: if something fails, the work goes back to the implementing model for fixes.
In other words, it isn’t about generating an answer in one shot, but about working through several rounds of review and improvement.
What’s interesting is not the model names, which will probably be replaced soon enough. It is that the example shows clearly how a system can reserve the expensive model for the tasks that need judgment and accountability, while leaving the repetitive, high-volume work to a far cheaper one. Astra supervises and Flash does most of the operational work. It is an uneven distribution of responsibility and decision-making power, not simply swapping a pricey model for a cheap one.
The savings promise, and what it actually proves
This is where a more critical stance is warranted. In the original GitHub discussion, the author says he cut Astra usage by roughly 94% during a 23-hour development session.
A later analysis of the project by RuntimeWire reports a reduction of up to 98.9% in input tokens consumed by Astra per thousand lines of code implemented and tested. That figure, however, rests on a single local comparison, not a controlled benchmark.
These are two different numbers, obtained in different ways, and they should be read as such: figures shared by the project’s own author, not results of an independent evaluation that we can apply to any kind of work.
What would a genuinely useful benchmark include? To begin with, the models used, their versions, prices and the date of measurement. It should describe the repositories tested, their size and difficulty, the number of tasks, the success rate and what exactly counts as a result of equal quality.
It would also have to count the tokens generated by all the agents involved, not just the premium model being evaluated, and the cost of mistakes: retries, corrections, extra information needed and the human time spent fixing problems. Beyond that, it should report total elapsed time (not just the tokens saved on paper), how often errors go unnoticed and how serious they are, and the specific situations where delegation performs worse than simply using the most advanced model directly.
One more detail: at the time of writing, the repository has no official releases. That suggests a young, experimental project rather than a mature tool ready for production.
And it bears repeating: saving premium-model tokens does not automatically mean saving money or time, or reducing the risk of the process as a whole.
Verifying is as hard as delegating
There is an indie video game, Return of the Obra Dinn, in which the player must reconstruct what happened to every member of a ship’s crew from small, ambiguous clues: a frozen image, a half-heard sentence, a detail in the position of the bodies. The game confirms a deduction only when several related facts are correct together, not one by one.
It may seem an odd comparison, but it captures one of the central problems of orchestration. A delegation system only works if it has a reliable way of knowing when an agent’s result is actually correct. And that check can almost never rely on a single isolated signal. You have to combine several clues, as in the game. Otherwise we risk accepting an answer that looks coherent but isn’t.
In software development we have some fairly reliable signals: the project compiles, unit and integration tests pass, static analysis and linting are clean, benchmarks hold, and a person or another model reviews the changes.
But even then, passing tests doesn’t automatically mean the change is correct, safe and consistent with what the product was meant to do. Someone wrote those tests, and they may have left out precisely the trickiest edge cases.
In editorial, research, legal or medical work, verification is much harder. A well-written text can seem completely convincing and still contain wrong sources, invented quotes or conclusions the original material doesn’t support.
Let’s say it plainly: orchestration does not eliminate the reliability problem. It moves it from generating answers to designing the control mechanisms. That is a different problem, but not necessarily an easier one.
Not an isolated case
Astra Flash is part of a much broader and increasingly visible trend. Platforms are no longer just shipping ever larger models. They are also building tools to combine agents, let them talk to each other, give them different tools and make them work together through shared workflows.
A clear sign is the emergence of dedicated interoperability protocols. In April 2025, Google introduced the Agent2Agent Protocol, known as A2A, designed so that agents built on different platforms or frameworks can communicate, exchange information and coordinate actions. Two months later, in June, Google donated the protocol to the Linux Foundation, with the backing of companies including AWS, Cisco, Salesforce, SAP and ServiceNow.
This step matters more than it looks. It shows the conversation moving away from standalone agents built by a single vendor and toward compatibility between whole agent systems built by different companies.
That doesn’t mean the delegation problem is solved. It means interoperability and coordination are now treated as serious infrastructure problems, not just experiments to show off at conferences.
What the major guides recommend
Anthropic advocates a pragmatic approach in its guide to building agents: start with the simplest possible solution, and add agents, routing and more autonomy only when the gains justify the added complexity. In its view, the orchestrator-workers pattern is most useful when you can’t anticipate which subtasks will be needed, as often happens in development work that touches several files at once.
Andrew Ng names reflection, tool use, planning and multi-agent collaboration as core patterns of agentic design. His view is valuable because it puts workflow design back at the center. Often the real improvement doesn’t come only from the latest model on the market, but from how the system plans, acts, receives external information and corrects its own output.
OpenAI, in its own practical guide to optimizing agents, recommends measuring a baseline first and then changing things gradually. Its recommendations include:
- Improve the information the model receives and avoid passing unnecessary context.
- Review which tools are available to it.
- Send simpler tasks to smaller models.
- Use caching for repeated prompts.
- Separate tasks that need an immediate answer from those that can run asynchronously.
- Keep tracking and evaluating results systematically.
The guide also warns, indirectly, about using routing without judgment: too many rules and assignment steps can add needless work when the original task was simple to begin with.
The takeaway is fairly clear. None of these sources seriously argues that multiplying the number of agents is always a good idea. They converge on a more sensible principle: add complexity only when measurements show it really improves the outcome.
Where this architecture makes sense, and where it doesn’t
Whether orchestration pays off depends on how repeatable and measurable a task is, and on whether we have clear ways to verify its results.
- Customer support. Classifying queries, searching a knowledge base and drafting first replies delegate well. Complex complaints, exceptions and large refunds should still go through a person.
- Software development. Repository search, repetitive changes, tests and code checks are good candidates for delegation. Architecture decisions, major migrations and security reviews should stay with the most advanced model or, better still, a person.
- Editorial research, which is exactly the kind of work behind this article and many others I write. Extracting information from documents, grouping similar sources or preparing a first summary can go to a cheaper model. But choosing reliable sources, checking quotes and forming an opinion should stay under direct human supervision. That is where an article’s credibility is won or lost.
The hidden cost of coordination
Every agent or step added to a workflow means more calls, more tokens and possibly more waiting time. It also means more information to pass along or summarize between parts of the system, more chances for an early error to spread unnoticed, and more difficulty reproducing and understanding what failed when something goes wrong.
On top of that come more credentials, tools, permissions and potential entry points for attacks to manage, and it becomes harder to reconstruct afterward which model or agent actually made a given decision.
The efficiency that looks obvious on paper can hide an enormous coordination cost. It can even reach the point where nobody in the organization has a full picture of what is going on.
The opposite of “one model can do everything” is “many agents can do everything together,” and it is just as wrong. A network of agents is not automatically more competent, just as a ten-person meeting isn’t necessarily more effective than one well-prepared person working alone.
Security: delegating also means distributing power
Orchestration isn’t only about saving money. When an agent has tools to work with, it can search documents, run code, modify a repository, send messages, update a database or trigger company processes.
At that point the question is no longer just “is the text it generated any good?” but “what actions can this system actually perform in the real world?”
Some principles hold regardless of architecture:
- Least privilege: each agent should have only the permissions its task requires.
- Permission separation: clearly distinguish between reading information, modifying it and taking irreversible actions.
- Human confirmation: sending, buying, deleting, publishing and changes to production should require a person’s approval.
- Logging and traceability: you should be able to reconstruct which plan was followed, which tools were used, which sources were consulted, what result was produced, who reviewed it and whether the case was escalated.
- Isolation: agents that run code or handle untrusted information should do so in controlled environments.
- Protection against malicious instructions: hidden instructions in documents, web pages or other external inputs must not be able to manipulate the system’s behavior.
Put simply, an orchestrator is also a system of permissions and authorizations. Deciding who does each task means deciding who can act on which resources, and within what limits.
The metrics that really matter
Before claiming that one workflow is better than another, we should carefully measure at least these:
- Success rate on real tasks. A cheap system that doesn’t solve the problems isn’t efficient, however little it costs.
- Quality against a baseline. Compare against a concrete alternative, whether a single model or a fully human process.
- Total cost of the process. Include the router, the worker agents, the reviewers, retries, external tools and the human oversight that is still needed, not just the price of the most advanced model.
- Total response time. More stages can turn a fast answer into a long wait.
- Escalation rate. If nearly every task ends up on the premium model anyway, routing is doing little.
- Undetected errors. Answers the system accepts but that are actually wrong remain the biggest risk.
- Human review time. Savings on API costs can end up shifted onto the team’s working hours, without that extra cost appearing anywhere in the budget.
- Reproducibility and security. These are essential for understanding, fixing and verifying failures when, inevitably, they appear.
Which brings us back to Astra Flash Orchestrator. Astra’s token savings are an interesting data point, but on their own they don’t prove the workflow is better. What matters is overall efficiency at the same level of quality and risk.
Conclusion: from AI as a model to AI as an organization
The question “which is the best model?” isn’t going away. It still matters for understanding which capabilities are available at any given moment. But on its own it explains less and less about how the AI applications we use every day actually work.
A modern system might use one model to plan, another for repetitive tasks, an external tool to check data or carry out specific actions, and finally a person to approve whatever should never be fully automated.
The pieces on task switching, the Fable 5 and Opus 5 case, and tools like Astra Flash Orchestrator tell, from different angles, the same story. We are moving away from seeing AI as a single interlocutor we can ask for anything. It increasingly resembles an infrastructure made of delegation systems, control mechanisms, tools and shared responsibilities.
The lesson to keep in mind is that we mustn’t confuse what a technology promises with what it actually delivers.
The real innovation isn’t simply getting many models to collaborate, however catchy their names or impressive their advertised savings. It is designing a workflow in which every step makes sense, can be measured and checked, and, above all, is overseen by someone who takes responsibility for what happens.

