T
Thomas Cherickal
Guest
AI-generated image
Eight Platforms, Ten Tasks, Ten Agent Teams, What Each One Costs, and How to Remove that Cost using Local LLMs
I. Introduction to Agent Orchestration and the Power of Local LLMs
Why orchestration skills are in demand, what agents cost, and how local LLMs remove that cost.
II. How To Stay Under Budget
Seven rules and one hook that keep your token bills small.
III. Claude Code
A five-agent full-stack feature build with Anthropic's terminal agent.
IV. OpenAI Codex
A parallel test-coverage sweep using codex exec and git worktrees.
V. xAI Grok
Three competing landing-page prototypes, judged by a critic agent.
VI. Google Gemini
Mapping a legacy monorepo with Antigravity CLI's background agents.
VII. Microsoft Copilot
A 12-package dependency upgrade with /fleet and /delegate.
VIII. OpenCode
Complete API documentation from cheap readers and one premium writer.
IX. Pi Code
Four-language localisation with a scripted team of Pi workers.
X. DeepSeek
An overnight 200-file type-hint migration at off-peak prices.
XI. Master Agent Workflow (From Anthropic)
The orchestrator-worker pattern, its results, and a universal lead prompt.
XII. When To Use Multiple Agents
The patterns where an agent team earns its token bill.
XIII. When Not To Use Multiple Agents
The cases where a single agent beats a team.
XIV. Top Five Best Agent Harnesses
My ranking of the harnesses for daily multi-agent work.
XV. Skills Required For Agentic Orchestration
Ten skills that turn an agent user into a conductor.
XVI. Why Local LLMs Are A Game-Changer For Low Budgets
Why 64 GB is the minimum, plus a fully local four-agent team.
XVII. Best Local LLMs For Agentic Coding with 64 GB Unified Memory
The 64 GB shortlist and a two-model local security-audit team.
XVIII. Summary
Every task, team and bill on one screen, plus the method in five points.
XIX. Free Course for AI Agent Orchestration
10 courses from Google, Microsoft, Kaggle, UC Berkeley and others that are completely free
References
The 51 sources behind the claims in this article.
There has been a statistic doing the rounds.
Job listings for AI orchestrators rose 1,294% in a single year, from February 2025 to February 2026, according to Lightcast data reported by IT Brew.
You could have thought, "Ah, running these agents costs a lot of money, especially if you are in Asia or Africa!".
I am here to give you a loophole that removes that cost entirely -
Local LLMs that fit in 64 GB of dedicated VRAM or even Unified Memory can perform orchestration for you!
That removes the cost problem - by effectively taking AI inference costs to zero.
Then you might have thought, "But AI Agent Orchestration must be a deep skill requiring an extremely in-depth knowledge of coding! After all, they pay so much!".
Again - not so much.
The top three skills you need across AI Agent Orchestration?
1. Advanced knowledge of Git
2. Intermediate Knowledge of Bash (Linux - don't use Windows, please)
3. Domain Knowledge the task you are orchestrating
And the real depth - practice and experience.
You can pick up AI Agent Orchestration in a month with dedicated practice.
And costs can be next to zero for AI (apart from the hardware) with Local LLMs.
Don't believe me?
Keep reading!
Also; to cover an important caveat:
Do not run 100+ agents on Claude everyday - unless you can pay $1,000+ per month for the API or a $200 Max subscription every month.
Obviously, this does not apply if you are running your own local LLM.
That is how you get over the cost problem.
You can definitely orchestrate multiple agents with local LLMs!
Local LLMs like Gemma 4 or Qwen 3.8 are the best option for 20 USD AI subscribers.
However, their output quality will not be optimal.
But we digress.
Anthropic measured the cost of agents carefully in its write-up on how it built its multi-agent research system, and the numbers are sobering.
More agents means more tokens, and more tokens means more money.
So the honest starting point of AI agent orchestration is not spinning up ten agents at once—it is setting a budget and deciding what each agent is worth to you.
However, with local LLMs, that problem disappears.
Read to the end to find out everything!
Orchestration is simple to describe, even though it takes practice to do well. In every setup in this article, the roles break down the same way.
1. One lead agent sets the goal, writes the plan, and enforces the constraints and the budget.
2. Several worker agents do focused jobs in parallel, each inside its own separate context window.
3. One verifier—another agent or a human—checks the combined result before anything is merged.
The developers who learn to conduct agents, rather than simply chat with them, are quietly becoming 10X engineers.
They are not typing any faster than before.
They are delegating far better than before.
How do you create a new agent in Claude?
You ask!
Just prompt “Create an agent to do task [X] (whatever your task is).”
Or:
“Create three agents. One to check for missing logic, one to update the documentation, and one to add unit tests.”
As easy as that, you are orchestrating multiple agents!
However, that does not work for all AI coding systems.
Hence - the remainder of this article!
These are list prices taken from official pricing pages and recent reporting. Regional pricing, including pricing in India, can differ from the figures below.
Every provider section ends with an estimated bill for its task, and you should read those bills with three caveats in mind.
This is important for efficiency even while using Local LLMs.
And companies pay 500,000 USD for employees who automate entire teams with Claude!
The single most important idea in this entire article is that context is the meter.
Every turn re-sends the conversation, every tool call adds its output to the pile, and every new agent starts a pile of its own.
Anthropic's guide to managing Claude Code costs puts real numbers on this, and they are worth memorising.
Keep that in mind when you are sponsoring your own agent bills.
Of course, the figures above are for Claude alone.
1. Route work by difficulty, not by habit. Use frontier models for architecture and hard debugging, mid-tier models for implementation, and small models for search, log reading, and running tests.
2. Clear the context between unrelated tasks. Running
3. Keep your instruction files lean. Anthropic recommends keeping
4. Push noisy work into subagents or hooks. A subagent can read 10,000 lines of test output and return a three-line summary, and a hook can filter that output before any model sees it at all.
5. Prefer command-line tools over unused MCP servers. Tools such as
6. Run locally before you run in the cloud. OpenAI states plainly that Codex cloud tasks consume more of your allowance than equivalent local work.
7. Put a hard cap on spending. Claude Code supports a
The hook below filters test output so that only failures reach the model. It is adapted from Anthropic's own documentation, and on a large test suite it can save thousands of tokens on every single run.
json
bash
Claude Code is the best tool for tightly managed feature work, because each subagent gets its own model, its own tools, and its own context window.
That lets one lead keep the design coherent while specialists do the heavy lifting in parallel.
Step 1. Install Claude Code with the native installer, which keeps itself up to date in the background.
bash
Step 2. Create the folder where project-level subagents live, from the root of your repository.
bash
Step 3. Create the first agent,
bash
Step 4. Create the second agent,
bash
Step 5. Create the third agent,
bash
Step 6. Create the fourth agent,
bash
Step 7. Start the lead session on Opus, so the strongest model does the planning while cheaper models do the work.
bash
Step 8. Press
Step 9. Launch the workers in parallel with a single instruction to the lead.
text
Step 10. Run
On a Pro or Max plan, this work comes out of your plan allowance rather than your card.
On the API, prompt caching usually brings the real figure well below five dollars.
Codex is the best tool for headless, scriptable fan-out, because
When you combine it with
Step 1. Install Codex and sign in with your ChatGPT account on the first run.
bash
Step 2. Put your shared conventions in
Step 3. Use
Step 4. Create four isolated worktrees, one for each agent, so that every agent works on its own branch and folder.
bash
Step 5. Launch the four test-writing agents in parallel, each inside its own worktree.
bash
Step 6. Launch the fifth agent, the reviewer, once all four branches exist.
bash
Step 7. Fix whatever the reviewer flags, merge each branch, and remove the worktrees with
This estimate assumes API-equivalent pricing of $1.75 per million input tokens and $14 per million output tokens, which is the GPT-5.3-Codex rate reported in Jetadmin's Codex pricing breakdown.
On a Plus plan at $20 a month, a run of this size typically fits inside your rolling five-hour usage window.
Grok Build is ideal when speed matters more than secrecy.
Prototypes are disposable, they are often public anyway, and they benefit enormously from a fast model.
So the best use is to let several agents race each other and let a critic agent pick the winner.
Step 1. Install Grok Build with the official installer script.
bash
Step 2. Start Grok in a fresh, non-confidential repository, and complete the browser sign-in on the first launch.
bash
Step 3. Ask Grok, in plan mode, to plan the shared brief covering the audience, the page sections, and the constraints, and approve that plan before anything runs.
Step 4. Spawn the three prototype agents in parallel, each in its own git worktree.
text
Step 5. Spawn the fourth agent, the critic, with strict instructions not to edit anything.
text
Step 6. Script future runs in headless mode, which returns machine-readable output that you can pipe into other tools.
bash
This estimate assumes $2 per million input tokens and $6 per million output tokens, the Grok 4.6 API price listed in the independent research note above. My confidence in this figure is low, because xAI's pricing has changed several times this year.
On a SuperGrok subscription, CLI usage is covered by the plan rather than billed per token.
Gemini models are built for very long context windows, and Antigravity adds background agents that keep working while you do something else.
That combination is perfect for reading a huge, unfamiliar codebase without blocking your day. The task here is to produce an architecture brief for a legacy monorepo with four subsystems.
I expect drastic changes when Gemini 4 Argon is released. Can’t wait!
Step 1. Install Antigravity CLI as a fresh binary, because it is a new tool rather than an upgrade of Gemini CLI.
bash
Step 2. Find every remaining call to the old
bash
Step 3. Launch
Step 4. Spawn the four mapping agents as read-only background agents.
text
Step 5. Keep working in the foreground while the agents run, and use
Step 6. Ask the lead to merge the four reports into a single architecture document.
text
This estimate assumes a Gemini Pro-class rate of $2 per million input tokens and $12 per million output tokens.
Reading is the expensive part of this task, which is exactly why it belongs on a long-context model with a free tier.
Copilot is the best tool for work that lives right next to your pull requests.
The
Step 1. Install the Copilot CLI, which requires Node.js 22 or later when installed through npm.
bash
Step 2. Run
Step 3. Use
Step 4. Create the 12 subagents with a single
text
Step 5. Review the fleet report, merge every package that reported PASS, and list the packages that reported FAIL.
Step 6. Create one cloud agent per failed package with
text
Step 7. Script the next upgrade check in non-interactive mode, which prints quiet output suitable for CI.
bash
This estimate assumes that AI credits track the underlying model cost at $0.01 per credit, using a mid-tier model priced at $2 per million input tokens and $10 per million output tokens.
Copilot Pro's $15 of monthly credits covers roughly two runs of this size.
Pay attention here because OpenCode is one of the best options to use for Local LLMs.
OpenCode is the best tool for mixing cheap and premium models inside one team.
Documentation needs a great deal of reading and only a little excellent writing, so cheap models should do the reading and one premium model should do the writing.
Step 1. Install OpenCode with the official installer script.
bash
Step 2. Run
Step 3. Run
Step 4. Create the first agent,
bash
Step 5. Create the second agent,
bash
Step 6. Use
Step 7. Run the whole team with one instruction to the Build agent.
text
Step 8. Use
That is the real power of per-agent models: seven agents for less than the price of a cup of filter coffee at Cafe Coffee Day in India.
And for Local LLMs - that cost drops to zero.
Pi is the best tool for batch jobs that you script yourself, because each Pi process is a small, predictable worker.
Run several of them from one shell script and you have an orchestrator with no framework overhead at all.
Step 1. Install Pi with the official installer, or with npm if you prefer.
bash
Step 2. Start
Step 3. Write the orchestration script, which creates four translator agents and one verifier agent.
bash
Step 4. Create the logs folder, make the script executable, and run it.
bash
Step 5. Ask a native speaker to spot-check the results, because machine translation still needs a human ear for tone, especially in Tamil and Hindi.
Pi will not hold your hand at any point, and that is precisely why experienced developers love it.
DeepSeek is the best engine for high-volume, low-risk, well-tested mechanical work.
The changes are repetitive, the test suite catches mistakes, and off-peak pricing halves the bill while you sleep.
DeepSeek's Anthropic-compatible API guide maps Claude model names onto its own models, which lets you run this team inside Claude Code.
Step 1. Create a DeepSeek API key on the DeepSeek platform and top up a small balance.
Step 2. Point Claude Code at DeepSeek for the current terminal session only, so your normal Claude sessions remain untouched.
bash
Step 3. Create the four typing agents in one loop, each responsible for its own batch of files.
bash
Step 4. Split the Python files into four roughly equal batches.
bash
Step 5. Start the lead session during off-peak hours, because DeepSeek serves the
bash
Step 6. Launch the four workers in parallel with one instruction to the lead.
text
Step 7. Close the terminal when the run is complete, which discards the DeepSeek environment variables.
Two hundred type-hinted files for under two dollars is, quite literally, all in a night's work (lol).
Everything above is tooling, and this section is the method that ties it together.
Anthropic has published the clearest public blueprint for multi-agent work in two pieces.
1. The lead agent analyses the request, writes a plan, and saves that plan to memory.
2. The lead spawns workers, giving each one an objective, an output format, guidance on tools, and clear task boundaries.
3. The workers run in parallel, each inside its own context window.
4. Each worker returns condensed findings rather than raw dumps of everything it read.
5. The lead synthesises the findings and decides whether to loop again or to finish.
6. A final pass verifies the output, which in Anthropic's case is a dedicated citation step.
The results were not subtle.
A system with Claude Opus 4 as the lead and Claude Sonnet 4 workers outperformed a single Claude Opus 4 agent by 90.2% on Anthropic's internal research evaluation.
Parallel tool calling also cut research time by up to 90% on complex queries.
1. Teach the lead to delegate precisely. When Anthropic's lead agent gave vague instructions, its workers duplicated each other's work and wasted tokens.
2. Scale the effort to the complexity of the task. Simple fact-finding needs one agent with three to ten tool calls, direct comparisons need two to four workers with ten to fifteen calls each, and complex research may need more than ten workers with clearly divided responsibilities.
3. Start wide, then narrow down. Broad queries come first and specific queries come second, which is exactly how a good human researcher works.
4. Lead with a smart model and work with cheaper ones. The split between the lead model and the worker models is itself a budget strategy.
5. Judge the end state rather than the path. Agents take different valid routes to the same answer, so evaluate the outcome with an LLM-as-judge rubric plus human spot checks.
You can paste the prompt below into any harness that supports subagents, and it will apply the whole Anthropic method in one go.
text
In short, the lead plans, the workers explore, the lead builds, and a stranger checks the result.
The asnwer - depth and width.
For simple tasks and most projects, chat-based agents are enough.
But when you want to launch a 10,000 agent task -
When you are refactoring a huge codebase from Python to Go, or TypeScript to Rust -
The skills above become a part of the job.
I am preparing you to take your first steps into orchestrating 10,000 agents plus.
At that scale - all the techniques above become must-have.
We are just scratching the surface of what is possible with AI agents - and huge budgets.
Big projects demand big budgets, because they require frontier models.
That includes scientific discovery, automated research, and authoring math research papers (looking at you, OpenAI)!
Multiple agents pay for themselves when the work is wide, the pieces are independent, and the results are easy to verify.
Every task in Sections III to X fits that shape, which is why each of them earns its bill.
If the work is wide, if the pieces are independent, and if you can check the result cheaply, then more agents genuinely means more work done, faster.
Anthropic's own post says that multi-agent systems are a poor fit where agents must share context or depend heavily on each other, and it names most coding tasks as an example.
There are cases where Multiple Agents or Agentic Teams are a poor fit.
It is important that every agent orchestrator expert understands and recognizes these cases.
Most expertise comes from experience.
But some expertise can also come from guidelines - see below:
Start with one agent and a good plan and add a second agent only when you can name the specific reason—isolation, parallelism, or independent review.
If you cannot name the reason -
You almost certainly do not need the second agent.
A harness is everything that surrounds the model: the tools, the permissions, the context management, and the subagent machinery.
The same model can perform very differently inside different harnesses, which is why rankings such as Terminal-Bench 2.0 score harness-and-model pairs rather than models alone.
This ranking reflects daily multi-agent work in October 2026, and it is my opinion, grounded in the evidence presented above.
1. Claude Code. It has the deepest orchestration toolkit, with subagents, agent teams, hooks, skills, and workflows, and the best cost documentation of any vendor.
2. OpenAI Codex CLI. It has the strongest verified benchmark result I found, a score of 82 on Terminal-Bench 2.0, and
3. OpenCode. It offers the best value, with any provider, a different model per agent, and a free client.
4. GitHub Copilot CLI. Its
5. Pi. It is minimal, transparent, scriptable, and embeddable, which makes it the best foundation for building your own orchestrator.
There are two honourable mentions worth watching.
Orchestration looks like a tooling problem, but it is really a skills problem.
The tools in this article are all learnable in an afternoon, while the skills below take months to sharpen—and they are what separates a developer who runs agents from a developer who conducts them.
1. Decomposition. You must be able to break a goal into pieces that are genuinely independent, because agents that share hidden dependencies will collide. Practise by writing a task list before every feature and marking which items could run in parallel.
2. Writing precise briefs. Every delegation needs an objective, a scope, an out-of-scope list, an output format, and a stopping condition. Anthropic found that vague briefs caused its workers to duplicate each other, so this is the single most valuable skill on the list.
3. Context engineering. You need to know what belongs in
4. Git fluency. Branches, worktrees, rebasing, and conflict resolution become daily tools once several agents are writing code at once. If
5. Testing and verification. Agents are only as trustworthy as the checks that catch their mistakes, so you need strong test suites, type checkers, and linters. Tests turn "the agent says it works" into "the agent proved it works."
6. Code review at speed. You will read far more diffs than you write, so you must spot weak tests, silent behaviour changes, and security issues quickly. Pairing a human review with a second-vendor agent review is the safest combination.
7. Token and cost literacy. You should be able to estimate a task's token cost before you run it, read
8. Security and permissions hygiene. You must decide which agents may edit files, run commands, or reach the network, and you must keep secrets out of prompts and logs. Least privilege applies to agents just as much as it applies to people.
9. Shell scripting and automation. Headless modes such as
10. Evaluation. You need a way to judge whether a multi-agent setup actually beats a single agent on your own work, such as a small benchmark of real tasks graded by rubric. Without evaluation, you are spending money on faith rather than evidence.
The fastest way to build these skills is to start small and deliberate.
Anthropic's free Claude Academy courses, including Claude Code 101 and Claude Code in Action, are an excellent starting point, and every vendor's documentation linked in the References section is worth reading end to end.
https://academy.claude.com/?embedable=true
Every bill in this article so far has been a token bill, and token bills grow with every agent you add.
Local models change that equation completely.
Once you own the hardware, the marginal cost of a token is a little electricity, so running five agents costs almost the same as running one.
Let me be precise about what "low budget" means here.
Local models give you a very low running budget, not a low starting budget, because the hardware is a real one-time purchase.
If you cannot make that purchase today, the cloud options in Sections II and X remain the right answer, and nothing in this section changes that.
I now treat 64 GB of unified memory as the minimum for serious local agent orchestration.
A 32 GB machine can run one good coding model at 4-bit precision with a modest context window, but it cannot hold a proper agent team.
At 64 GB, everything that makes orchestration work locally becomes possible.
macOS normally lets the GPU use about 75% of unified memory, which is roughly 48 GB on a 64 GB Mac.
The LLM Configurator guide to raising the Metal memory limit shows how to lift that to about 54 GB with a single
That 48–54 GB budget is what every recommendation in Sections XVI and XVII is designed around.
The new M6 Mac mini tops out at 32 GB, so it cannot meet the 64 GB minimum at any price.
Local models are a game-changer, but they are not magic, and you should go in with clear eyes.
The smartest budget setup is usually a hybrid.
Let a cloud model act as the lead for planning and final review, and let local models do the high-volume worker jobs such as reading, searching, writing tests, and summarising logs.
OpenCode makes this easy, because each agent can point at a different provider, so a single team can mix one paid model with several free local ones.
Ollama exposes an Anthropic-compatible API, so Claude Code can run entirely on a local model, as described in Ollama's Claude Code integration guide.
On a 64 GB Mac, the whole team can run on the 8-bit version of Qwen3.8-27B.
Step 1. Install Ollama, which runs local models and serves them over a local API.
bash
Step 2. Optionally raise the GPU memory limit on your 64 GB Mac so the model and its context have more room, keeping at least 10 GB free for macOS.
bash
Step 3. Start the Ollama server with a 64K context window, which Ollama recommends for Claude Code, and allow two requests at once so two agents can work in parallel.
bash
Step 4. In a second terminal, download the 8-bit model that the whole team will share.
bash
Step 5. Create the three worker agents, each set to inherit the session's local model.
bash
Step 6. Point Claude Code at Ollama, switch off non-essential network traffic, and start the lead session on the local model.
bash
Step 7. Give the lead one instruction that runs the whole team.
text
Step 8. Confirm the work with
The same team on cloud APIs would cost several dollars, as Section III showed, and every rerun would cost the same again.
Locally, a rerun costs a few cents of electricity, and that is what makes local models a genuine game-changer for anyone who wants to keep running costs low.
Sixty-four gigabytes is the floor for a real local agent team in 2026, not a luxury.
It is the smallest memory size that holds the best 27-billion-parameter coding models at 8-bit precision with room to spare, and it is the smallest size that keeps a lead model and a worker model loaded at the same time.
A model has to fit together with its working memory, not on its own, so plan your 64 GB with these rules in mind.
All scores below are coding results published by each model's maker or reported in the source linked beside it.
SWE-bench Verified and SWE-bench Pro are different, non-comparable benchmarks, so compare scores only within the same benchmark, and always test on your own code before you commit.
If you take one thing away from this section - create your own benchmark from your codebase, and verify your local model with that.
Two popular models do not make this list for a simple reason: they do not fit.
OpenAI's gpt-oss-120b is 65 GB on Ollama and Qwen3.5-122B-A10B is 81 GB, both above a 64 GB Mac's GPU budget, so they need a machine with more than 64 GB of unified memory.
1. Qwen3.8-27B — the best overall lead agent. Its official model card reports 61.7 on SWE-bench Pro, well ahead of Qwen3.6-27B's 53.5, under an Apache 2.0 licence with a 256K native context. At 8-bit it uses about 30 GB, which leaves comfortable room on a 64 GB Mac for context and a second agent.
2. Qwen3.6-27B — the proven dense alternative. Its official model card lists 77.2 on SWE-bench Verified and 59.3 on Terminal-Bench 2.0, and it has months of community testing behind it. Use it when you want a well-understood model with the same memory footprint as Qwen3.8-27B.
3. Qwen3.6-35B-A3B — the fastest serious worker. With only 3 billion of its 35 billion parameters active per token, its official model card shows 73.4 on SWE-bench Verified at far higher speed than the dense models. At 8-bit it takes 39 GB, so on 64 GB it works best either alone or at 4-bit (24 GB) alongside a lead model.
4. Laguna XS 2.1 — the agentic specialist. Poolside released this 33B-total, 3B-active mixture-of-experts model on 2 July 2026, built specifically for agentic coding, as OpenSourceForU reported in its coverage of Poolside's Laguna models. Its 8-bit build is 36 GB on the Ollama Laguna XS 2.1 page, under the OpenMDW-1.1 licence. I could not find a published benchmark score, so my confidence in it is moderate and it is best treated as promising rather than proven.
5. Muse Glimmer 30B — the long-session alternative. DataCamp's overview of Meta's Muse Glimmer reports 76.0 on SWE-bench Verified and an Apache 2.0 licence. It trails the Qwen models on terminal tasks, so use it where long, multi-step agent sessions matter more than shell work.
6. Devstral Small 2 — the lightweight repository specialist. Mistral's Devstral 2 announcement lists 68.0 on SWE-bench Verified and a 256K context window for this 24-billion-parameter model. At 15 GB it is the easiest model here to pair with another, which makes it a good scout or test runner in a two-model team.
Again, run your own benchmarks, with your own code.
I commit to writing an article on that in the near future!
This is the setup that 64 GB makes possible and 32 GB does not: a strong dense model leads and verifies, while a fast mixture-of-experts model does the parallel reading.
Step 1. Raise the GPU memory limit, then download both models, which together take about 42 GB.
bash
Step 2. Start Ollama so both models can stay loaded at once, with three parallel slots and a moderate context.
bash
Step 3. Register both local models in the project's
json
Step 4. Create the
bash
Step 5. Create the
bash
Step 6. Start
text
Step 7. Run
Sixty-four gigabytes of memory, a free harness, and an open-weight model now add up to a genuine two-model coding team that costs cents to run.
If your work grows beyond that, a machine with more unified memory is the natural next step.
Buy the largest memory capacity you can afford within reason.
Your future self will thank you.
Here is the whole article on one screen, with every task, team size, and rough bill side by side.
The last two rows assume a 64 GB Mac, which this article treats as the minimum for local agent teams.
1. Set the budget before you set the task.
2. Let one lead agent plan, let cheap worker agents explore, and let the lead integrate the results.
3. Route every subtask to the cheapest model that can do it well—and if you go local, start at 64 GB of unified memory.
4. Verify everything with a different model, a test suite, or a human reviewer.
5. Add another agent only when you can name the specific reason for it.
I strongly believe that AI agent orchestration is the most important developer skill of 2026.
It matters more than prompting tricks and far more than vibe coding, because it turns one developer into the conductor of a small, tireless team.
Keep one cloud frontier model like Claude on a low subscription for planning.
Run the majority of the work locally with your local LLM, unless you are doing research or frontier engineering, in which case a $200 USD subscription to Claude will earn its keep.
So plan your work, delegate it precisely, verify the results, merge with confidence, and repeat the cycle every day.
Then run
Finally, if you are choosing a skill to master this year - choose AI agent orchestration, in a field where you are already deep.
The breakthrough technology of the next few years will be AI Agent engineering.
I found some courses for that which I cannot help sharing because I want to get the best information and updates for my readers!
Why?
They are free to learn, are given by industry leaders, and gives you hands-on experience with AI agents.
Given below:
All courses below are free.
1. Microsoft: AI Agents for Beginners
https://github.com/microsoft/ai-agents-for-beginners
An open-source course on GitHub covering tool use, agentic RAG, planning, multi-agent systems and metacognition. The code runs on GitHub Models, which is free with usage limits. It’s the gentlest starting point.
2. Kaggle and Google: 5-Day AI Agents Intensive (2025 edition)
https://www.kaggle.com/learn-guide/5-day-agents
More than 1.5 million learners took the November 2025 live run, and it’s now a self-paced Kaggle Learn Guide. Each day pairs a whitepaper and podcast with code notebooks. You need a free Kaggle account.
3. Hugging Face: AI Agents Course
https://huggingface.co/learn/agents-course
It goes from first principles through three frameworks (smolagents, LangGraph and LlamaIndex) to a final agent you benchmark on a leaderboard. The certificate is free and is awarded for completing the capstone.
4. Kaggle and Google: 5-Day AI Agents, Intensive Vibe Coding (2026 edition)
https://www.kaggle.com/learn-guide/5-day-agents-vibecoding
The June 2026 follow-up to course 2. It covers multi-agent systems, memory and skills, security, and turning prototype agents into a managed, monitored production setup. You need free Kaggle and Google AI Studio accounts. The capstone and cloud-deployment exercises are optional and may need a Google Cloud account with billing enabled, so skip those to stay at zero cost.
5. Microsoft: MCP for Beginners
https://github.com/microsoft/mcp-for-beginners
An open-source course on the Model Context Protocol (MCP), with examples in .NET, Java, TypeScript, JavaScript, Rust and Python. MCP is how agents in an orchestrated system reach tools and data. It also covers security risks such as prompt injection.
6. Hugging Face: MCP Course
https://huggingface.co/learn/mcp-course
Built with Anthropic, it takes you from MCP basics to a deployed MCP application, with a free certificate. It goes deeper than course 5 on building real servers.
7. LangChain Academy: Introduction to LangGraph
https://academy.langchain.com/courses/intro-to-langgraph
Free, with 55 lessons and 6 hours of video covering state, memory, human-in-the-loop, parallel branches, sub-graphs, map-reduce and long-term memory. It’s the most hands-on course here on orchestration as explicit graphs. The notebooks default to OpenAI models, which bill per use; you can swap in a free model such as Gemini on Google AI Studio’s free tier or a local model through Ollama.
These three are free recorded lecture series from UC Berkeley, taught by researchers. They explain why orchestration designs work rather than how to code them.
8. UC Berkeley: LLM Agents MOOC (Fall 2024)
https://llmagents-learning.org/f24
The first course in the series: LLM foundations, reasoning, planning and tool use, agent infrastructure, retrieval, and multimodal agents.
9. UC Berkeley: Advanced LLM Agents MOOC (Spring 2025)
https://rdi.berkeley.edu/adv-llm-agents/sp25
Builds on course 8 with reasoning, AI for mathematics, code generation and program verification. Lectures include reasoning, memory and planning in language agents, coding agents, and multimodal autonomous agents.
10. UC Berkeley: Agentic AI MOOC (Fall 2025)
https://agenticai-learning.org/f25
The newest course in the series, with guest lecturers from OpenAI, Google DeepMind, NVIDIA, Microsoft, Stanford and Sony AI. Lectures include Multi-Agent AI by Noam Brown (OpenAI) and agent safety and security by Dawn Song.
Suggested order: 1, then 3, then 5 and 6 for tool integration, 7 for hands-on orchestration, 4 for production, and 8 to 10 for the research view if necessary.
Take at least three courses, upskill, and practice with open-source repositories.
Make videos of your AI agent orchestration learning.
And; with some six months of hard dedicated work and open-source repositories of your own -
The recruiters will be calling you for a $500K+ USD role!
All the very best to you and your future career!
Cheers!
1. Lightcast data reported by IT Brew — https://www.itbrew.com/stories/ai-orchestrators-are-the-newest-in-demand-ai-role
2. How Anthropic built its multi-agent research system — https://www.anthropic.com/engineering/multi-agent-research-system
3. Anthropic: Building effective agents — https://www.anthropic.com/engineering/building-effective-agents
4. Claude Code overview and installation docs — https://code.claude.com/docs/en/overview
5. Manage Claude Code costs effectively — https://code.claude.com/docs/en/costs
6. Dynamic workflows in Claude Code announcement — https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code
7. Claude plans and API pricing — https://claude.com/pricing
8. OpenAI Codex CLI documentation — https://learn.chatgpt.com/docs/codex/cli
9. OpenAI Codex pricing and usage limits — https://learn.chatgpt.com/docs/pricing
10. Jetadmin: Codex pricing and realistic budgets 2026 — https://www.jetadmin.io/blog/codex-pricing-current-costs-usage-limits-and-realistic-budgets-2026/
11. Codesota Terminal-Bench 2.0 leaderboard — https://www.codesota.com/browse/agentic/autonomous-coding/terminal-bench-2
12. xAI official news timeline — https://x.ai/news
13. Grok Build getting-started documentation — https://docs.x.ai/build/overview
14. Ry Walker research note on Grok Build — https://rywalker.com/research/grok-build
15. Google: transitioning Gemini CLI to Antigravity CLI — https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/
16. Antigravity CLI getting-started documentation — https://antigravity.google/docs/getting-started?tab=cli
17. Claude Academy free courses — https://academy.claude.com/
18. GitHub Copilot CLI getting-started guide — https://docs.github.com/en/copilot/how-tos/copilot-cli/cli-getting-started
19. GitHub docs on the /fleet command — https://docs.github.com/en/copilot/concepts/agents/copilot-cli/fleet
20. GitHub Copilot plans and AI credits — https://github.com/features/copilot/plans
21. OpenCode getting-started documentation — https://opencode.ai/docs
22. OpenCode agents and subagents documentation — https://opencode.ai/docs/agents
23. OpenCode Zen pricing documentation — https://opencode.ai/docs/zen
24. Pi official website and documentation — https://pi.dev
25. DeepSeek API models and pricing — https://api-docs.deepseek.com/quick_start/pricing
26. DeepSeek Anthropic-compatible API guide — https://api-docs.deepseek.com/guides/anthropic_api
27. Caixin: DeepSeek V4-Pro launch and price rises — https://www.caixinglobal.com/2026-0...-api-prices-by-as-much-as-1100-102474222.html
28. Cognition: Don't Build Multi-Agents essay — https://cognition.ai/blog/dont-build-multi-agents
29. Ollama's Claude Code integration guide — https://docs.ollama.com/integrations/claude-code
30. Qwen3.6-27B official model card — https://huggingface.co/Qwen/Qwen3.6-27B
31. Qwen3.6-35B-A3B official model card — https://huggingface.co/Qwen/Qwen3.6-35B-A3B
32. DataCamp overview of Meta's Muse Glimmer — https://www.datacamp.com/blog/muse-glimmer
33. Mistral: Devstral 2 and Vibe CLI announcement — https://mistral.ai/news/devstral-2-vibe-cli/
34. LLM Configurator: raising the Metal memory limit — https://llmconfigurator.com/en/guides/troubleshooting/increase-metal-vram-limit-apple-silicon
35. AppleInsider: M5 Pro versus M4 Pro Mac mini — https://appleinsider.com/articles/2...m4-pro-mac-mini-compared-specs-hardware-price
36. Qwen3.8-27B official model card — https://huggingface.co/Qwen/Qwen3.8-27B
37. Ollama: Qwen3.8 tags and sizes — https://ollama.com/library/qwen3.8/tags
38. OpenSourceForU: Poolside's open-weight Laguna models — https://www.opensourceforu.com/2026/07/poolside-ai-launches-open-weight-laguna-coding-models/
39. Ollama: Laguna XS 2.1 model page — https://ollama.com/library/laguna-xs-2.1
40. MacRumors: Apple's June 2026 price increases — https://www.macrumors.com/2026/06/25/apple-just-increased-prices/
41. TrendForce: 3Q26 DRAM contract price forecast — https://www.trendforce.com/presscenter/news/20260709-13140.html
42. AI PMs are paid $500K plus at top companies — https://www.linkedin.com/posts/productfaculty_an-ai-pm-is-not-paid-500k-to-use-ai-share/
43. microsoft/ai-agents-for-beginners: Microsoft’s free open-source course on agent basics, tool use, planning and multi-agent design, with Python samples that run on GitHub Models’ free tier.
44. Google blog: AI Agents Intensive recap: Google’s recap of the November 2025 agents intensive, which links to the free self-paced Kaggle Learn Guide version.
45. Kaggle: 5-Day AI Agents Intensive Vibe Coding: The June 2026 edition, now self-paced, covering multi-agent systems, memory, security and moving agents into production.
46. Hugging Face Agents Course: A free certified course that goes from agent fundamentals through smolagents, LangGraph and LlamaIndex to a benchmarked capstone agent.
47. Hugging Face MCP Course: A free certified course, built with Anthropic, that takes you from MCP basics to a deployed MCP application.
48. microsoft/mcp-for-beginners: Microsoft’s open-source MCP course with server and client examples in .NET, Java, TypeScript, JavaScript, Rust and Python.
49. LangChain Academy: Introduction to LangGraph: A free 55-lesson course on building stateful single-agent and multi-agent workflows with LangGraph.
50. Berkeley RDI: Advanced LLM Agents (Spring 2025): Free recorded Berkeley lectures on agent reasoning, planning, coding agents and multimodal agents.
51. Berkeley RDI: Agentic AI (Fall 2025): Berkeley’s latest free lecture series on designing, evaluating, deploying and securing agentic systems, with speakers from OpenAI, Google DeepMind and NVIDIA.
The Digital Futurist · https://thomascherickal.com · https://thomascherickal.github.io
Eight Platforms, Ten Tasks, Ten Agent Teams, What Each One Costs, and How to Remove that Cost using Local LLMs
Table of Contents
I. Introduction to Agent Orchestration and the Power of Local LLMs
Why orchestration skills are in demand, what agents cost, and how local LLMs remove that cost.
II. How To Stay Under Budget
Seven rules and one hook that keep your token bills small.
III. Claude Code
A five-agent full-stack feature build with Anthropic's terminal agent.
IV. OpenAI Codex
A parallel test-coverage sweep using codex exec and git worktrees.
V. xAI Grok
Three competing landing-page prototypes, judged by a critic agent.
VI. Google Gemini
Mapping a legacy monorepo with Antigravity CLI's background agents.
VII. Microsoft Copilot
A 12-package dependency upgrade with /fleet and /delegate.
VIII. OpenCode
Complete API documentation from cheap readers and one premium writer.
IX. Pi Code
Four-language localisation with a scripted team of Pi workers.
X. DeepSeek
An overnight 200-file type-hint migration at off-peak prices.
XI. Master Agent Workflow (From Anthropic)
The orchestrator-worker pattern, its results, and a universal lead prompt.
XII. When To Use Multiple Agents
The patterns where an agent team earns its token bill.
XIII. When Not To Use Multiple Agents
The cases where a single agent beats a team.
XIV. Top Five Best Agent Harnesses
My ranking of the harnesses for daily multi-agent work.
XV. Skills Required For Agentic Orchestration
Ten skills that turn an agent user into a conductor.
XVI. Why Local LLMs Are A Game-Changer For Low Budgets
Why 64 GB is the minimum, plus a fully local four-agent team.
XVII. Best Local LLMs For Agentic Coding with 64 GB Unified Memory
The 64 GB shortlist and a two-model local security-audit team.
XVIII. Summary
Every task, team and bill on one screen, plus the method in five points.
XIX. Free Course for AI Agent Orchestration
10 courses from Google, Microsoft, Kaggle, UC Berkeley and others that are completely free
References
The 51 sources behind the claims in this article.
I. Introduction to Agent Orchestration and the Power of Local LLMs
There has been a statistic doing the rounds.
Job listings for AI orchestrators rose 1,294% in a single year, from February 2025 to February 2026, according to Lightcast data reported by IT Brew.
You could have thought, "Ah, running these agents costs a lot of money, especially if you are in Asia or Africa!".
I am here to give you a loophole that removes that cost entirely -
Local LLMs that fit in 64 GB of dedicated VRAM or even Unified Memory can perform orchestration for you!
That removes the cost problem - by effectively taking AI inference costs to zero.
Then you might have thought, "But AI Agent Orchestration must be a deep skill requiring an extremely in-depth knowledge of coding! After all, they pay so much!".
Again - not so much.
The top three skills you need across AI Agent Orchestration?
1. Advanced knowledge of Git
2. Intermediate Knowledge of Bash (Linux - don't use Windows, please)
3. Domain Knowledge the task you are orchestrating
- Basic Software Engineering Principles (SOLID, TDD, DRY, KISS, DDD is a plus)
And the real depth - practice and experience.
You can pick up AI Agent Orchestration in a month with dedicated practice.
And costs can be next to zero for AI (apart from the hardware) with Local LLMs.
Don't believe me?
Keep reading!
Also; to cover an important caveat:
Do not run 100+ agents on Claude everyday - unless you can pay $1,000+ per month for the API or a $200 Max subscription every month.
Obviously, this does not apply if you are running your own local LLM.
That is how you get over the cost problem.
You can definitely orchestrate multiple agents with local LLMs!
Local LLMs like Gemma 4 or Qwen 3.8 are the best option for 20 USD AI subscribers.
However, their output quality will not be optimal.
But we digress.
Anthropic measured the cost of agents carefully in its write-up on how it built its multi-agent research system, and the numbers are sobering.
- A single agent uses roughly four times the tokens of an ordinary chat conversation.
- A multi-agent system uses roughly fifteen times the tokens of an ordinary chat conversation.
- Token usage alone explained about 80% of the performance difference in Anthropic’s browsing evaluation.
More agents means more tokens, and more tokens means more money.
So the honest starting point of AI agent orchestration is not spinning up ten agents at once—it is setting a budget and deciding what each agent is worth to you.
However, with local LLMs, that problem disappears.
Read to the end to find out everything!
What Orchestration Actually Means
Orchestration is simple to describe, even though it takes practice to do well. In every setup in this article, the roles break down the same way.
1. One lead agent sets the goal, writes the plan, and enforces the constraints and the budget.
2. Several worker agents do focused jobs in parallel, each inside its own separate context window.
3. One verifier—another agent or a human—checks the combined result before anything is merged.
The developers who learn to conduct agents, rather than simply chat with them, are quietly becoming 10X engineers.
They are not typing any faster than before.
They are delegating far better than before.
The Crux - TL;DR in Short
How do you create a new agent in Claude?
You ask!
Just prompt “Create an agent to do task [X] (whatever your task is).”
Or:
“Create three agents. One to check for missing logic, one to update the documentation, and one to add unit tests.”
As easy as that, you are orchestrating multiple agents!
However, that does not work for all AI coding systems.
Hence - the remainder of this article!
The Entry Tickets In October 2026
These are list prices taken from official pricing pages and recent reporting. Regional pricing, including pricing in India, can differ from the figures below.
| Provider | Entry Plan | Heavy-Use Plan | Pay-As-You-Go |
|---|---|---|---|
| Anthropic (Claude Code) | Pro, $20/month | Max, from $100/month | Sonnet 5.5: $2 / $10 per M tokens |
| OpenAI (Codex) | Go $8, Plus $20 | Pro: $100, $200, $500 | Credits and API keys |
| xAI (Grok Build) | SuperGrok or X Premium+ | Higher SuperGrok tiers | xAI API |
| Google (Antigravity CLI) | Free tier with AI credits | Enterprise via Google Cloud | Paid API keys |
| Microsoft (GitHub Copilot) | Pro $10 ($15 in credits) | Pro+ $39, Max $100 | $0.01 per extra credit |
| OpenCode | Free client, some free models | — | Zen per token, or your own key |
| Pi | Free client | — | Your own key |
| DeepSeek | No subscription | — | V4-Pro: $0.66 / $1.98 per M (off-peak) |
How To Read The Bills In This Article
Every provider section ends with an estimated bill for its task, and you should read those bills with three caveats in mind.
- Each bill uses list API prices and token counts that I assumed for a mid-sized repository, not measured usage.
- Prompt caching usually reduces the real figure, sometimes quite sharply, because repeated context is billed at a discount.
- On a subscription such as Pro, Max, Plus, or SuperGrok, the same work draws down your plan allowance instead of charging your card.
II. How To Stay Under Budget
This is important for efficiency even while using Local LLMs.
And companies pay 500,000 USD for employees who automate entire teams with Claude!
The single most important idea in this entire article is that context is the meter.
Every turn re-sends the conversation, every tool call adds its output to the pile, and every new agent starts a pile of its own.
Anthropic's guide to managing Claude Code costs puts real numbers on this, and they are worth memorising.
- Average enterprise spend is about $13 per developer per active day.
- Monthly spend typically runs between $150 and $250 per developer.
- Ninety percent of users stay below $30 per active day.
- Agent teams use roughly seven times the tokens of a standard session when teammates run in plan mode.
Keep that in mind when you are sponsoring your own agent bills.
Of course, the figures above are for Claude alone.
Seven Rules That Keep You Under Budget
1. Route work by difficulty, not by habit. Use frontier models for architecture and hard debugging, mid-tier models for implementation, and small models for search, log reading, and running tests.
2. Clear the context between unrelated tasks. Running
/clear in Claude Code costs nothing, whereas /compact is itself a large request because the model must read everything it summarises.3. Keep your instruction files lean. Anthropic recommends keeping
CLAUDE.md under 200 lines and moving specialist workflows into skills, which load only when they are needed.4. Push noisy work into subagents or hooks. A subagent can read 10,000 lines of test output and return a three-line summary, and a hook can filter that output before any model sees it at all.
5. Prefer command-line tools over unused MCP servers. Tools such as
gh, gcloud, and aws cost almost nothing in context, while every idle MCP server adds a small cost to every request.6. Run locally before you run in the cloud. OpenAI states plainly that Codex cloud tasks consume more of your allowance than equivalent local work.
7. Put a hard cap on spending. Claude Code supports a
--max-budget-usd flag for scripted runs, Copilot lets you keep overages switched off, and DeepSeek charges half price during off-peak hours.The Cheapest Hook You Will Ever Write
The hook below filters test output so that only failures reach the model. It is adapted from Anthropic's own documentation, and on a large test suite it can save thousands of tokens on every single run.
json
Code:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{ "type": "command", "command": "~/.claude/hooks/filter-test-output.sh" }
]
}
]
}
}bash
Code:
#!/bin/bash
# filter-test-output.sh — runs BEFORE every Bash call Claude Code makes.
# If the command is a test runner, rewrite it so only failures come back.
input=$(cat) # hook payload arrives as JSON on stdin
cmd=$(echo "$input" | jq -r '.tool_input.command') # the shell command Claude wants to run
if [[ "$cmd" =~ ^(npm test|pytest|go test|cargo test) ]]; then
# Keep only FAIL/ERROR lines plus 5 lines of context, capped at 100 lines
filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"
# Allow the call, but with the filtered command
echo "$input" | jq --arg filtered "$filtered_cmd" \
'{hookSpecificOutput: {hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: (.tool_input + {command: $filtered})}}'
else
echo "{}" # any other command passes through untouched
fiIII. Claude Code
In Brief
- Claude Code is Anthropic's agentic coding tool, and it runs in the terminal, in VS Code and JetBrains, in a desktop app, and on the web.
- Every surface shares the same engine, the same
CLAUDE.mdfiles, and the same MCP servers, so your setup travels with you. - It offers the deepest orchestration toolkit available today, including subagents, agent teams, hooks, skills, plugins, and dynamic workflows.
- It is included with Pro at $20 a month and with Max from $100 to $200 a month, according to Claude's official pricing page.
The Perfect Task: Build A Full-Stack Feature End To End
Claude Code is the best tool for tightly managed feature work, because each subagent gets its own model, its own tools, and its own context window.
That lets one lead keep the design coherent while specialists do the heavy lifting in parallel.
The Agent Team
| Agent | Model | Job |
|---|---|---|
| Lead (your session) | Opus 5.5 | Plans, assigns, and integrates |
backend-dev | Sonnet 5.5 | Builds the API endpoint |
frontend-dev | Sonnet 5.5 | Builds the export button and flow |
test-runner | Haiku 5.5 | Runs tests and reports only failures |
reviewer | Sonnet 5.5 | Reviews the final diff in read-only mode |
Step-By-Step
Step 1. Install Claude Code with the native installer, which keeps itself up to date in the background.
bash
Code:
# macOS, Linux, or WSL — the native installer auto-updates
curl -fsSL https://claude.ai/install.sh | bash
claude --version # a version number means the install workedStep 2. Create the folder where project-level subagents live, from the root of your repository.
bash
Code:
cd your-project
mkdir -p .claude/agents # every .md file in here becomes a subagentStep 3. Create the first agent,
backend-dev, which may only touch server-side files.bash
Code:
cat > .claude/agents/backend-dev.md <<'EOF'
---
name: backend-dev
description: Implements backend API changes only. Use for server-side tasks.
model: sonnet # mid-tier model for implementation work
tools: Read, Edit, Write, Bash
---
You implement API endpoints. Touch only files under src/api/ and src/services/.
Return a short summary of the files you changed and why.
EOFStep 4. Create the second agent,
frontend-dev, which may only touch client-side files.bash
Code:
cat > .claude/agents/frontend-dev.md <<'EOF'
---
name: frontend-dev
description: Implements UI changes only. Use for client-side tasks.
model: sonnet
tools: Read, Edit, Write, Bash
---
You build UI components. Touch only files under src/web/.
Return a short summary of the files you changed and why.
EOFStep 5. Create the third agent,
test-runner, on the smallest model, because reading logs needs no deep reasoning.bash
Code:
cat > .claude/agents/test-runner.md <<'EOF'
---
name: test-runner
description: Runs the test suite and reports ONLY failures. Use after any change.
model: haiku # small, fast and cheap — ideal for reading logs
tools: Bash, Read # can run and read, but never edit
---
Run the tests. Return the test name, file:line, and a one-line probable cause. Never paste full logs.
EOFStep 6. Create the fourth agent,
reviewer, which can read and run git diff but cannot edit anything.bash
Code:
cat > .claude/agents/reviewer.md <<'EOF'
---
name: reviewer
description: Reviews diffs for bugs, security issues and missing tests. Read-only.
model: sonnet
tools: Read, Bash # Bash is only for git diff; there are no editing tools
---
Review the current branch against main. Return a numbered list of issues, most severe first.
EOFStep 7. Start the lead session on Opus, so the strongest model does the planning while cheaper models do the work.
bash
Code:
claude --model opusStep 8. Press
Shift+Tab to enter plan mode, ask for a plan for the CSV export feature, and approve the plan before any code is written.Step 9. Launch the workers in parallel with a single instruction to the lead.
text
Code:
Use backend-dev and frontend-dev in parallel to implement the approved plan.
When both finish, use test-runner. Fix any failures yourself.
Finally, use reviewer and address every issue it raises.Step 10. Run
/usage when the work is done, because it attributes your spend to each subagent and shows you where the tokens went.Estimated Bill
| Agent | Tokens In / Out | Cost At List Price |
|---|---|---|
| Lead (Opus 5.5, $4 / $20) | 300K / 30K | $1.80 |
| backend-dev (Sonnet 5.5, $2 / $10) | 400K / 40K | $1.20 |
| frontend-dev (Sonnet 5.5) | 400K / 40K | $1.20 |
| test-runner (Haiku 5.5, $1 / $5) | 300K / 10K | $0.35 |
| reviewer (Sonnet 5.5) | 200K / 15K | $0.55 |
| Total | | ≈ $5.10 |
On a Pro or Max plan, this work comes out of your plan allowance rather than your card.
On the API, prompt caching usually brings the real figure well below five dollars.
IV. OpenAI Codex
In Brief
- Codex is OpenAI's coding agent, and it is bundled into ChatGPT plans rather than sold as a separate product.
- It runs as a command-line tool, an IDE extension, a web app, and a cloud sandbox that returns results to your repository.
- The
codex execcommand runs Codex non-interactively, which makes it ideal for scripts and continuous integration. - The default model is GPT-6.1 Sol at medium reasoning, according to OpenAI's Codex CLI documentation.
- Codex paired with GPT-5.5 holds the top Terminal-Bench 2.0 entry, a score of 82 in April 2026, on the Codesota Terminal-Bench 2.0 leaderboard.
The Perfect Task: A Parallel Test-Coverage Sweep
Codex is the best tool for headless, scriptable fan-out, because
codex exec turns each agent into a single shell command.When you combine it with
git worktree, every agent gets its own isolated copy of the repository and the agents can never overwrite each other.The Agent Team
| Agent | Where It Runs | Job |
|---|---|---|
tests-auth | Worktree 1 | Tests for packages/auth |
tests-billing | Worktree 2 | Tests for packages/billing |
tests-search | Worktree 3 | Tests for packages/search |
tests-notify | Worktree 4 | Tests for packages/notify |
reviewer | Main repository | Audits all four branches |
Step-By-Step
Step 1. Install Codex and sign in with your ChatGPT account on the first run.
bash
Code:
curl -fsSL https://chatgpt.com/codex/install.sh | sh
codex # the first run walks you through ChatGPT sign-inStep 2. Put your shared conventions in
AGENTS.md, which Codex reads automatically and which Claude Code can also read, so your rules travel between vendors.Step 3. Use
/permissions, or your Codex configuration, to allow codex exec to edit files and run tests for this task, and keep the settings conservative everywhere else.Step 4. Create four isolated worktrees, one for each agent, so that every agent works on its own branch and folder.
bash
Code:
# One branch and one folder per package, so the agents never collide
for pkg in auth billing search notify; do
git worktree add ../wt-$pkg -b tests/$pkg
doneStep 5. Launch the four test-writing agents in parallel, each inside its own worktree.
bash
Code:
# Each subshell is one Codex agent working inside its own worktree
for pkg in auth billing search notify; do
( cd ../wt-$pkg && \
codex exec "Write missing unit tests for packages/$pkg. Run them until they pass. \
Do not modify any other package. Commit when done." \
> ../log-$pkg.md 2>&1 ) & # run in the background and save each agent's report
done
wait # block until all four agents have finishedStep 6. Launch the fifth agent, the reviewer, once all four branches exist.
bash
Code:
codex exec "Review branches tests/auth, tests/billing, tests/search and tests/notify \
against main. Flag weak assertions, flaky tests and missing edge cases. \
Output a numbered list per branch." > review.mdStep 7. Fix whatever the reviewer flags, merge each branch, and remove the worktrees with
git worktree remove ../wt-<package>.Estimated Bill
This estimate assumes API-equivalent pricing of $1.75 per million input tokens and $14 per million output tokens, which is the GPT-5.3-Codex rate reported in Jetadmin's Codex pricing breakdown.
| Agent | Tokens In / Out | Cost |
|---|---|---|
| 4 test-writing agents | 500K / 40K each | $5.74 |
| reviewer | 300K / 20K | $0.81 |
| Total | | ≈ $6.55 |
On a Plus plan at $20 a month, a run of this size typically fits inside your rolling five-hour usage window.
V. xAI Grok
In Brief
- Grok Build is xAI's terminal coding agent, and its CLI entered early beta on May 25, 2026, for SuperGrok and X Premium Plus subscribers.
- xAI open-sourced the harness on July 15, 2026, according to the official xAI news timeline.
- It offers plan mode, subagents, a headless mode for scripting, and a fast dedicated coding model called Grok Build 0.1.
- An independent research note on Grok Build's July 2026 upload incident reports that it uploaded repository bundles against users' wishes until a server-side fix stopped it, so keep it on open or throwaway code for now.
The Perfect Task: Rapid Prototyping With Competing Variants
Grok Build is ideal when speed matters more than secrecy.
Prototypes are disposable, they are often public anyway, and they benefit enormously from a fast model.
So the best use is to let several agents race each other and let a critic agent pick the winner.
The Agent Team
| Agent | Job |
|---|---|
| Lead (your session) | Writes the brief, then spawns and judges the agents |
proto-minimal | Builds a minimal, typography-led design |
proto-bold | Builds a bold, illustration-heavy design |
proto-docs | Builds a documentation-first, developer-focused design |
critic | Scores all three designs against the brief |
Step-By-Step
Step 1. Install Grok Build with the official installer script.
bash
Code:
curl -fsSL https://x.ai/cli/install.sh | bash # macOS / Linux / WSL
# Windows PowerShell: irm https://x.ai/cli/install.ps1 | iexStep 2. Start Grok in a fresh, non-confidential repository, and complete the browser sign-in on the first launch.
bash
Code:
mkdir landing-race && cd landing-race && git init
grok # the first launch opens browser sign-inStep 3. Ask Grok, in plan mode, to plan the shared brief covering the audience, the page sections, and the constraints, and approve that plan before anything runs.
Step 4. Spawn the three prototype agents in parallel, each in its own git worktree.
text
Code:
Spawn three subagents in parallel, each in its own git worktree:
1. proto-minimal: a minimal, typography-led landing page.
2. proto-bold: a bold, illustration-heavy landing page.
3. proto-docs: a docs-first page with a live code sample.
Each must follow the approved brief and build as static HTML/CSS.Step 5. Spawn the fourth agent, the critic, with strict instructions not to edit anything.
text
Code:
Spawn a fourth subagent, critic. It must not edit anything.
Score each prototype from 1 to 10 on clarity, speed and fit to the brief, then recommend one.Step 6. Script future runs in headless mode, which returns machine-readable output that you can pipe into other tools.
bash
Code:
# A headless one-shot with streaming JSON output, handy for nightly variant runs
grok -p "Re-run the critic on all three worktrees" --output-format streaming-jsonEstimated Bill
This estimate assumes $2 per million input tokens and $6 per million output tokens, the Grok 4.6 API price listed in the independent research note above. My confidence in this figure is low, because xAI's pricing has changed several times this year.
| Agent | Tokens In / Out | Cost |
|---|---|---|
| Lead | 100K / 10K | $0.26 |
| 3 prototype agents | 200K / 30K each | $1.74 |
| critic | 150K / 10K | $0.36 |
| Total | | ≈ $2.36 |
On a SuperGrok subscription, CLI usage is covered by the plan rather than billed per token.
VI. Google Gemini
In Brief
- Gemini CLI stopped serving free users, Google AI Pro subscribers, and Google AI Ultra subscribers on June 18, 2026.
- Its replacement is Antigravity CLI, a new binary called
agythat Google rebuilt in Go and that shares its agent harness with the Antigravity 2.0 desktop app. - Antigravity is designed for asynchronous, multi-agent work, so agents can run in the background while you keep using the terminal.
- These details come from Google's official post on moving Gemini CLI to Antigravity CLI.
The Perfect Task: Map A Legacy Monorepo
Gemini models are built for very long context windows, and Antigravity adds background agents that keep working while you do something else.
That combination is perfect for reading a huge, unfamiliar codebase without blocking your day. The task here is to produce an architecture brief for a legacy monorepo with four subsystems.
I expect drastic changes when Gemini 4 Argon is released. Can’t wait!
The Agent Team
| Agent | Job |
|---|---|
| Lead (your session) | Splits the repository and merges the reports |
map-api | Maps the API gateway and its routes |
map-data | Maps the database layer and its migrations |
map-jobs | Maps background jobs and queues |
map-web | Maps the front end and every API call it makes |
Step-By-Step
Step 1. Install Antigravity CLI as a fresh binary, because it is a new tool rather than an upgrade of Gemini CLI.
bash
Code:
curl -fsSL https://antigravity.google/cli/install.sh | bash # installs `agy` to ~/.local/bin
# Windows PowerShell: irm https://antigravity.google/cli/install.ps1 | iexStep 2. Find every remaining call to the old
gemini command in your scripts and CI configuration, because those calls stopped working on June 18 if they used consumer credentials.bash
Code:
# Search scripts and CI configs for lingering references to the retired CLI
grep -rn --include="*.yml" --include="*.yaml" --include="*.sh" "gemini " .Step 3. Launch
agy from the root of the repository and confirm workspace trust during the first-run setup.Step 4. Spawn the four mapping agents as read-only background agents.
text
Code:
Spawn four background agents, each read-only:
1. map-api: map the gateway, routes and auth flow under services/api/.
2. map-data: map schemas, migrations and data access under services/db/.
3. map-jobs: map queues, workers and schedules under services/jobs/.
4. map-web: map the front end and every API call it makes under apps/web/.
Each writes its findings to docs/arch/<agent-name>.md, max 80 lines.Step 5. Keep working in the foreground while the agents run, and use
/agents to watch and manage them.Step 6. Ask the lead to merge the four reports into a single architecture document.
text
Code:
Read docs/arch/*.md and write docs/ARCHITECTURE.md: a one-page overview,
a dependency list between subsystems, and the top five risks.Estimated Bill
This estimate assumes a Gemini Pro-class rate of $2 per million input tokens and $12 per million output tokens.
| Agent | Tokens In / Out | Cost |
|---|---|---|
| Lead | 200K / 20K | $0.64 |
| 4 mapping agents | 800K / 20K each | $7.36 |
| Total | | ≈ $8.00 |
Reading is the expensive part of this task, which is exactly why it belongs on a long-context model with a free tier.
VII. Microsoft Copilot
In Brief
- For coding agents, the Microsoft product that matters is GitHub Copilot, while Microsoft 365 Copilot is a separate product for documents and email.
- The Copilot CLI includes
/fleet, which runs parallel subagents, and/delegate, which hands a task to the cloud coding agent. - The plans are Free, Pro at $10, Pro+ at $39, and Max at $100, with extra usage at $0.01 per credit, according to GitHub's Copilot plans page.
The Perfect Task: A Dependency Upgrade Across Many Packages
Copilot is the best tool for work that lives right next to your pull requests.
The
/fleet command splits a repetitive job into parallel subagents, and /delegate sends the stubborn leftovers to a cloud agent that opens pull requests for you.The Agent Team
| Agent | Job |
|---|---|
| Main agent (your session) | Plans the upgrade and coordinates the work |
| 12 /fleet subagents | One per package: upgrade, fix, and test |
| 2 /delegate cloud agents | Finish the packages that failed and open pull requests |
Step-By-Step
Step 1. Install the Copilot CLI, which requires Node.js 22 or later when installed through npm.
bash
Code:
npm install -g @github/copilot
# or: brew install --cask copilot-cli | winget install GitHub.CopilotStep 2. Run
copilot, then sign in once with /login, and note that organisation members need an administrator to enable the Copilot CLI policy first.Step 3. Use
/model to choose a mid-tier model, because mechanical edits do not need a frontier model.Step 4. Create the 12 subagents with a single
/fleet instruction.text
Code:
/fleet Upgrade our logging library from v3 to v4 in every package under packages/.
Use one subagent per package. Each subagent updates imports, fixes breaking
changes, runs that package's tests, and reports PASS or FAIL with one line of detail.Step 5. Review the fleet report, merge every package that reported PASS, and list the packages that reported FAIL.
Step 6. Create one cloud agent per failed package with
/delegate, and repeat the command for the second failed package.text
Code:
/delegate Finish the logging v4 upgrade in packages/payments. Tests are failing on
structured-field serialisation. Open a pull request when tests pass.Step 7. Script the next upgrade check in non-interactive mode, which prints quiet output suitable for CI.
bash
Code:
copilot -p "List every package still importing logging v3" -sEstimated Bill
This estimate assumes that AI credits track the underlying model cost at $0.01 per credit, using a mid-tier model priced at $2 per million input tokens and $10 per million output tokens.
| Agent | Tokens In / Out | Cost |
|---|---|---|
| Main agent | 200K / 20K | $0.60 |
| 12 fleet subagents | 150K / 10K each | $4.80 |
| 2 cloud agents | Rough allowance | $1.00 |
| Total | | ≈ $6.40 (about 640 credits) |
Copilot Pro's $15 of monthly credits covers roughly two runs of this size.
VIII. OpenCode
Pay attention here because OpenCode is one of the best options to use for Local LLMs.
In Brief
- OpenCode is an open-source, provider-agnostic terminal agent that works with almost any model provider.
- It has two primary agents, Build with full access and Plan with editing disabled by default, and you switch between them with the
Tabkey. - It ships with three subagents—General, Explore, and Scout—which you call with
@name. - Every agent can run on a different model, according to OpenCode's agents documentation, and the client itself is free.
The Perfect Task: Write API Documentation For A Whole Repository
OpenCode is the best tool for mixing cheap and premium models inside one team.
Documentation needs a great deal of reading and only a little excellent writing, so cheap models should do the reading and one premium model should do the writing.
The Agent Team
| Agent | Model | Job |
|---|---|---|
| Build (primary) | Sonnet 5.5 | Writes the final documentation |
doc-scout × 5 | deepseek-flash | Extracts signatures and behaviour, read-only |
doc-checker | deepseek-flash | Verifies every documented claim against the code |
Step-By-Step
Step 1. Install OpenCode with the official installer script.
bash
Code:
curl -fsSL https://opencode.ai/install | bashStep 2. Run
opencode, then use /connect to add two providers: Anthropic for the writer and DeepSeek for the readers.Step 3. Run
/init so that OpenCode analyses the project and generates an AGENTS.md file.Step 4. Create the first agent,
doc-scout, as a read-only subagent on a very cheap model.bash
Code:
mkdir -p ~/.config/opencode/agents
cat > ~/.config/opencode/agents/doc-scout.md <<'EOF'
---
description: Read-only extractor. Lists public functions, parameters, return values and side effects for ONE module.
mode: subagent # callable by the primary agent via @doc-scout
model: deepseek/deepseek-flash # a very low-cost model for high-volume reading
permission:
edit: deny # cannot change files
bash: deny # cannot run commands
---
For the module you are given, return a compact list of public APIs with one-line behaviour notes.
EOFStep 5. Create the second agent,
doc-checker, which compares the finished documentation against the source code.bash
Code:
cat > ~/.config/opencode/agents/doc-checker.md <<'EOF'
---
description: Fact-checks documentation against source code. Read-only.
mode: subagent
model: deepseek/deepseek-flash
permission:
edit: deny
bash: deny
---
Compare each documented claim with the code. Return only the claims that are wrong, with file:line.
EOFStep 6. Use
/models to select Sonnet 5.5 as the model for the Build agent, which will do the actual writing.Step 7. Run the whole team with one instruction to the Build agent.
text
Code:
Call @doc-scout five times in parallel, once each for src/core, src/api, src/db,
src/auth and src/utils. Using their output, write docs/reference/<module>.md files.
Then call @doc-checker on every new file and fix each error it reports.Step 8. Use
/undo and /redo freely if the output misses the mark, because they make experimentation cheap.Estimated Bill
| Agent | Tokens In / Out | Cost |
|---|---|---|
| 5 doc-scouts (flash, peak $0.30 / $1.20) | 400K / 30K each | $0.78 |
| Writer (Sonnet 5.5, $2 / $10) | 300K / 40K | $1.00 |
| doc-checker (flash) | 200K / 10K | $0.07 |
| Total | | ≈ $1.85 |
That is the real power of per-agent models: seven agents for less than the price of a cup of filter coffee at Cafe Coffee Day in India.
And for Local LLMs - that cost drops to zero.
IX. Pi Code
In Brief
- Pi is a deliberately minimal coding agent created by Mario Zechner, the developer behind libGDX.
- It has four core tools—read, write, edit, and bash—along with a short, publicly visible system prompt and support for more than fifteen providers.
- It runs interactively, in print or JSON mode, over RPC, or embedded inside your own application through an SDK.
- It intentionally ships without built-in subagents, and the official Pi website suggests using tmux or an extension instead.
The Perfect Task: Localise An App Into Four Languages
Pi is the best tool for batch jobs that you script yourself, because each Pi process is a small, predictable worker.
Run several of them from one shell script and you have an orchestrator with no framework overhead at all.
The Agent Team
| Agent | Job |
|---|---|
translate-hi | Translates English into Hindi |
translate-ta | Translates English into Tamil |
translate-es | Translates English into Spanish |
translate-de | Translates English into German |
verifier | Checks keys, placeholders, and length limits |
Step-By-Step
Step 1. Install Pi with the official installer, or with npm if you prefer.
bash
Code:
curl -fsSL https://pi.dev/install.sh | sh
# npm alternative: npm install -g @earendil-works/pi-coding-agentStep 2. Start
pi, connect a provider, and use /model to select a small, inexpensive model such as Haiku 5.5.Step 3. Write the orchestration script, which creates four translator agents and one verifier agent.
bash
Code:
#!/bin/bash
# localise.sh — creates four translator agents and one verifier agent.
set -e
SRC=locales/en.json
# Agents 1-4: one Pi process per language, all running in parallel
for lang in hi ta es de; do
pi -p "Translate every value in $SRC into language code '$lang'. Keep all keys and \
{placeholders} unchanged. Write the result to locales/$lang.json." \
> logs/translate-$lang.md 2>&1 &
done
wait # block until all four translators have finished
# Agent 5: the verifier checks all four outputs against the English source
pi -p "Compare locales/en.json with hi.json, ta.json, es.json and de.json. Report missing keys, \
broken {placeholders} and button strings longer than 40 characters." > logs/verify.mdStep 4. Create the logs folder, make the script executable, and run it.
bash
Code:
mkdir -p logs && chmod +x localise.sh && ./localise.shStep 5. Ask a native speaker to spot-check the results, because machine translation still needs a human ear for tone, especially in Tamil and Hindi.
Estimated Bill
| Agent | Tokens In / Out | Cost (Haiku 5.5, $1 / $5) |
|---|---|---|
| 4 translators | 100K / 30K each | $1.00 |
| verifier | 150K / 10K | $0.20 |
| Total | | ≈ $1.20 |
Pi will not hold your hand at any point, and that is precisely why experienced developers love it.
X. DeepSeek
In Brief
- DeepSeek matters in this article as an engine that powers other agents, rather than as a separate agent of its own.
- It offers two models,
deepseek-flashanddeepseek-v4-pro, both with one-million-token context windows, and off-peak prices are half of peak prices according to the DeepSeek API pricing page. - V4-Pro launched on August 14, 2026, alongside peak price increases of up to 1,100%, as Caixin reported in its coverage of the V4-Pro launch.
- DeepSeek is a Chinese provider, so check your data-residency and contractual obligations before you send it any client code.
The Perfect Task: An Overnight Type-Hint Migration
DeepSeek is the best engine for high-volume, low-risk, well-tested mechanical work.
The changes are repetitive, the test suite catches mistakes, and off-peak pricing halves the bill while you sleep.
The Agent Team
DeepSeek's Anthropic-compatible API guide maps Claude model names onto its own models, which lets you run this team inside Claude Code.
| Agent | Requested Model | Served By | Job |
|---|---|---|---|
| Lead (your session) | opus | deepseek-v4-pro | Plans the batches and fixes hard cases |
typer-1 to typer-4 | haiku | deepseek-flash | 50 files each: add hints, run mypy |
Step-By-Step
Step 1. Create a DeepSeek API key on the DeepSeek platform and top up a small balance.
Step 2. Point Claude Code at DeepSeek for the current terminal session only, so your normal Claude sessions remain untouched.
bash
Code:
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic # DeepSeek's Anthropic-compatible endpoint
export ANTHROPIC_API_KEY="sk-..." # your DeepSeek key, not an Anthropic keyStep 3. Create the four typing agents in one loop, each responsible for its own batch of files.
bash
Code:
mkdir -p .claude/agents
for i in 1 2 3 4; do
cat > .claude/agents/typer-$i.md <<EOF
---
name: typer-$i
description: Adds type hints to batch $i of the Python files and makes mypy pass for that batch.
model: haiku # DeepSeek serves this request as deepseek-flash
tools: Read, Edit, Bash
---
Work only on the files listed in batches/batch-$i.txt. Add precise type hints.
Run mypy on those files until clean. Never change runtime behaviour.
EOF
doneStep 4. Split the Python files into four roughly equal batches.
bash
Code:
mkdir -p batches
git ls-files '*.py' > batches/all.txt # every tracked Python file
split -n l/4 -d -a 1 batches/all.txt batches/tmp- # four roughly equal file lists
for i in 0 1 2 3; do mv batches/tmp-$i batches/batch-$((i+1)).txt; doneStep 5. Start the lead session during off-peak hours, because DeepSeek serves the
opus request as deepseek-v4-pro.bash
Code:
claude --model opusStep 6. Launch the four workers in parallel with one instruction to the lead.
text
Code:
Run typer-1, typer-2, typer-3 and typer-4 in parallel. When all finish, run the full
test suite and mypy across the repo. Fix any remaining errors yourself.Step 7. Close the terminal when the run is complete, which discards the DeepSeek environment variables.
Estimated Bill (Off-Peak)
| Agent | Tokens In / Out | Cost |
|---|---|---|
| Lead (v4-pro, $0.66 / $1.98) | 500K / 50K | $0.43 |
| 4 typers (flash, $0.15 / $0.60) | 1.5M / 150K each | $1.26 |
| Total | | ≈ $1.70 (about $3.40 at peak) |
Two hundred type-hinted files for under two dollars is, quite literally, all in a night's work (lol).
XI. Master Agent Workflow (From Anthropic)
Everything above is tooling, and this section is the method that ties it together.
Anthropic has published the clearest public blueprint for multi-agent work in two pieces.
- Its December 2024 essay on building effective agents names and explains the orchestrator-workers pattern.
- Its June 2025 engineering post on the multi-agent research system shows that same pattern running in production.
The Architecture
1. The lead agent analyses the request, writes a plan, and saves that plan to memory.
2. The lead spawns workers, giving each one an objective, an output format, guidance on tools, and clear task boundaries.
3. The workers run in parallel, each inside its own context window.
4. Each worker returns condensed findings rather than raw dumps of everything it read.
5. The lead synthesises the findings and decides whether to loop again or to finish.
6. A final pass verifies the output, which in Anthropic's case is a dedicated citation step.
The Results
The results were not subtle.
A system with Claude Opus 4 as the lead and Claude Sonnet 4 workers outperformed a single Claude Opus 4 agent by 90.2% on Anthropic's internal research evaluation.
Parallel tool calling also cut research time by up to 90% on complex queries.
Five Lessons To Apply Daily
1. Teach the lead to delegate precisely. When Anthropic's lead agent gave vague instructions, its workers duplicated each other's work and wasted tokens.
2. Scale the effort to the complexity of the task. Simple fact-finding needs one agent with three to ten tool calls, direct comparisons need two to four workers with ten to fifteen calls each, and complex research may need more than ten workers with clearly divided responsibilities.
3. Start wide, then narrow down. Broad queries come first and specific queries come second, which is exactly how a good human researcher works.
4. Lead with a smart model and work with cheaper ones. The split between the lead model and the worker models is itself a budget strategy.
5. Judge the end state rather than the path. Agents take different valid routes to the same answer, so evaluate the outcome with an LLM-as-judge rubric plus human spot checks.
The Universal Lead Prompt
You can paste the prompt below into any harness that supports subagents, and it will apply the whole Anthropic method in one go.
text
Code:
You are the LEAD agent. Do not write code yet.
1. Read AGENTS.md and the task below. Write a plan to PLAN.md.
2. Classify the task: SIMPLE (do it yourself), COMPARISON (2-4 workers), or BROAD (5+ workers).
3. For each worker, define: objective, files in scope, files OUT of scope,
output format (max 30 lines), and model tier (small or medium).
4. Run workers in parallel. Collect results in FINDINGS.md.
5. Synthesise and implement on a branch yourself.
6. Spawn ONE reviewer on a different model to try to break your change.
Budget: stop and report if you exceed 15 worker calls.In short, the lead plans, the workers explore, the lead builds, and a stranger checks the result.
Interlude Caveat: Why All the Terminals We Can Simply Type into Chat?
The asnwer - depth and width.
For simple tasks and most projects, chat-based agents are enough.
But when you want to launch a 10,000 agent task -
When you are refactoring a huge codebase from Python to Go, or TypeScript to Rust -
The skills above become a part of the job.
I am preparing you to take your first steps into orchestrating 10,000 agents plus.
At that scale - all the techniques above become must-have.
We are just scratching the surface of what is possible with AI agents - and huge budgets.
Big projects demand big budgets, because they require frontier models.
That includes scientific discovery, automated research, and authoring math research papers (looking at you, OpenAI)!
XII. When To Use Multiple Agents
Multiple agents pay for themselves when the work is wide, the pieces are independent, and the results are easy to verify.
Every task in Sections III to X fits that shape, which is why each of them earns its bill.
The Patterns That Earn Their Bill
- Broad reading of a large codebase, as in the monorepo map from Section VI.
- Parallel, independent edits across many packages, as in the dependency upgrade from Section VII.
- Specialist roles working on one feature, as in the full-stack build from Section III.
- Competing drafts judged by a critic, as in the prototype race from Section V.
- Cheap readers feeding one premium writer, as in the documentation team from Section VIII.
- Batch processing of repetitive work, as in the localisation and type-hint tasks from Sections IX and X.
- Cross-vendor review, where Claude writes the code and Codex reviews it, or the other way around.
What These Patterns Make Possible
- Mapping a 400,000-line monorepo in a single afternoon - easy.
- Upgrading a dependency across 12 packages with tests passing - all in a day's (or night’s) work.
- Getting a second vendor's model to tear apart your pull request - no problem.
- Localising an app into four languages before lunch - sure thing!
- Waking up to 200 type-hinted files and a clean
mypyrun - done!
If the work is wide, if the pieces are independent, and if you can check the result cheaply, then more agents genuinely means more work done, faster.
XIII. When Not To Use Multiple Agents
Anthropic's own post says that multi-agent systems are a poor fit where agents must share context or depend heavily on each other, and it names most coding tasks as an example.
There are cases where Multiple Agents or Agentic Teams are a poor fit.
It is important that every agent orchestrator expert understands and recognizes these cases.
Most expertise comes from experience.
But some expertise can also come from guidelines - see below:
Do Not Use Multiple Agents When
- The change is tightly coupled, because shared state across five files needs one mind holding all five files at once.
- The task is small, because a bug with a clear stack trace needs one agent and one test, not a team.
- You cannot verify the output cheaply, because ten unreviewed diffs are technical debt rather than productivity.
- The budget is tight, because the multipliers are roughly 4X for an agent, 7X for an agent team, and 15X for a multi-agent system.
- The code is sensitive, because every extra vendor is one more place your code travels.
My Rule of Thumb
Start with one agent and a good plan and add a second agent only when you can name the specific reason—isolation, parallelism, or independent review.
If you cannot name the reason -
You almost certainly do not need the second agent.
XIV. Top Five Best Agent Harnesses
A harness is everything that surrounds the model: the tools, the permissions, the context management, and the subagent machinery.
The same model can perform very differently inside different harnesses, which is why rankings such as Terminal-Bench 2.0 score harness-and-model pairs rather than models alone.
This ranking reflects daily multi-agent work in October 2026, and it is my opinion, grounded in the evidence presented above.
1. Claude Code. It has the deepest orchestration toolkit, with subagents, agent teams, hooks, skills, and workflows, and the best cost documentation of any vendor.
2. OpenAI Codex CLI. It has the strongest verified benchmark result I found, a score of 82 on Terminal-Bench 2.0, and
codex exec makes headless fan-out trivial.3. OpenCode. It offers the best value, with any provider, a different model per agent, and a free client.
4. GitHub Copilot CLI. Its
/fleet and /delegate commands sit right next to your pull requests, which is a real advantage.5. Pi. It is minimal, transparent, scriptable, and embeddable, which makes it the best foundation for building your own orchestrator.
There are two honourable mentions worth watching.
- Antigravity CLI has a strong architecture, but it is still settling down after the forced migration from Gemini CLI.
- Grok Build is moving quickly, but the July incident keeps it off client work for now.
XV. Skills Required For Agentic Orchestration
Orchestration looks like a tooling problem, but it is really a skills problem.
The tools in this article are all learnable in an afternoon, while the skills below take months to sharpen—and they are what separates a developer who runs agents from a developer who conducts them.
1. Decomposition. You must be able to break a goal into pieces that are genuinely independent, because agents that share hidden dependencies will collide. Practise by writing a task list before every feature and marking which items could run in parallel.
2. Writing precise briefs. Every delegation needs an objective, a scope, an out-of-scope list, an output format, and a stopping condition. Anthropic found that vague briefs caused its workers to duplicate each other, so this is the single most valuable skill on the list.
3. Context engineering. You need to know what belongs in
CLAUDE.md or AGENTS.md, what belongs in a skill that loads on demand, and what should never enter the context at all. A lean context is both cheaper and more accurate.4. Git fluency. Branches, worktrees, rebasing, and conflict resolution become daily tools once several agents are writing code at once. If
git worktree is new to you, learn it before you run your first parallel team.5. Testing and verification. Agents are only as trustworthy as the checks that catch their mistakes, so you need strong test suites, type checkers, and linters. Tests turn "the agent says it works" into "the agent proved it works."
6. Code review at speed. You will read far more diffs than you write, so you must spot weak tests, silent behaviour changes, and security issues quickly. Pairing a human review with a second-vendor agent review is the safest combination.
7. Token and cost literacy. You should be able to estimate a task's token cost before you run it, read
/usage output, and choose the cheapest model that can do each job. Every bill in this article is an exercise in exactly this skill.8. Security and permissions hygiene. You must decide which agents may edit files, run commands, or reach the network, and you must keep secrets out of prompts and logs. Least privilege applies to agents just as much as it applies to people.
9. Shell scripting and automation. Headless modes such as
codex exec, claude -p, copilot -p, and pi -p turn agents into building blocks for scripts and CI pipelines. A little Bash goes a very long way in orchestration.10. Evaluation. You need a way to judge whether a multi-agent setup actually beats a single agent on your own work, such as a small benchmark of real tasks graded by rubric. Without evaluation, you are spending money on faith rather than evidence.
The fastest way to build these skills is to start small and deliberate.
Anthropic's free Claude Academy courses, including Claude Code 101 and Claude Code in Action, are an excellent starting point, and every vendor's documentation linked in the References section is worth reading end to end.
https://academy.claude.com/?embedable=true
XVI. Why Local LLMs Are a Game-Changer for Low Budgets
Every bill in this article so far has been a token bill, and token bills grow with every agent you add.
Local models change that equation completely.
Once you own the hardware, the marginal cost of a token is a little electricity, so running five agents costs almost the same as running one.
Let me be precise about what "low budget" means here.
Local models give you a very low running budget, not a low starting budget, because the hardware is a real one-time purchase.
If you cannot make that purchase today, the cloud options in Sections II and X remain the right answer, and nothing in this section changes that.
The Minimum: 64 GB Of Unified Memory
I now treat 64 GB of unified memory as the minimum for serious local agent orchestration.
A 32 GB machine can run one good coding model at 4-bit precision with a modest context window, but it cannot hold a proper agent team.
At 64 GB, everything that makes orchestration work locally becomes possible.
Higher-quality weights. The strongest 27-billion-parameter coding models fit at 8-bit precision, which is about 30 GB on Ollama, instead of being squeezed down to 4-bit.
Room for long contexts. Agents read whole files and long logs, and every extra token of context needs memory of its own on top of the model weights.
Several agents at once. Each parallel agent keeps its own context cache, so parallelism is a memory question before it is a speed question.
Two different models side by side. A strong lead model and a fast worker model can stay loaded together, which is exactly the lead-and-workers pattern from Section XI.
macOS normally lets the GPU use about 75% of unified memory, which is roughly 48 GB on a 64 GB Mac.
The LLM Configurator guide to raising the Metal memory limit shows how to lift that to about 54 GB with a single
sysctl command while leaving at least 10 GB for macOS.That 48–54 GB budget is what every recommendation in Sections XVI and XVII is designed around.
The Cheapest Ways To Reach 64 GB In October 2026
Mac mini with M5 Pro, 64 GB. This starts at about $2,699, calculated from the base price and the memory upgrade price in AppleInsider's M5 Pro versus M4 Pro Mac mini comparison.
Mac mini with M4 Pro, 64 GB. This works out to about $2,199 at current pricing, but AppleInsider notes that the M4 Pro model is now in limited supply.
Mac Studio with M5 Max, 64 GB. This costs about $3,499 and doubles the memory bandwidth, which makes every token arrive noticeably faster.
The new M6 Mac mini tops out at 32 GB, so it cannot meet the 64 GB minimum at any price.
Why Local Changes Everything
Zero marginal token cost. You can run a five-agent team all day, rerun failed experiments, and let agents read entire repositories without watching a per-token bill climb.
No usage windows or caps. There are no rolling five-hour limits, weekly caps, AI-credit allowances, or surprise overages, because the only limit is your own hardware.
Complete privacy. Your code never leaves your machine, which removes the data-residency worries raised in Section X and makes local agents ideal for confidential client work.
Predictable budgeting. Hardware is a fixed cost you can plan for, and a $2,699 Mac mini that replaces $200 of monthly cloud spend pays for itself in a little over a year—or in under six months if it replaces $500 a month.
Protection from token price changes. When a provider raises prices, as DeepSeek did in August 2026, a local setup keeps working at exactly the same cost.
A free orchestration laboratory. Because experiments cost nothing, you can practise every pattern in Section XI—fan-out, competing drafts, adversarial review—until it becomes second nature.
The Honest Trade-Offs
Local models are a game-changer, but they are not magic, and you should go in with clear eyes.
Quality still trails the frontier. Qwen3.8-27B scores 73.0 on Terminal-Bench 2.1 against 78.2 for Claude Opus 4.6 Max on its official model card, which is remarkably close but still behind.
Speed depends on memory bandwidth. The M5 Pro Mac mini offers 307 GB/s while the M5 Max Mac Studio offers up to 614 GB/s, and token generation speed on Apple silicon follows bandwidth closely.
Parallel agents share one machine. Several local agents can run at once, but they split the same memory and compute, so ten local agents are not ten times faster than one.
Hardware prices are rising. Apple raised Mac prices across the board in June 2026 because of the memory shortage, as MacRumors reported in its price-rise coverage, and TrendForce expects DRAM supply to stay tight into 2027, according to its July 2026 DRAM price forecast.
The Hybrid Pattern That Wins On A Budget
The smartest budget setup is usually a hybrid.
Let a cloud model act as the lead for planning and final review, and let local models do the high-volume worker jobs such as reading, searching, writing tests, and summarising logs.
OpenCode makes this easy, because each agent can point at a different provider, so a single team can mix one paid model with several free local ones.
Step-By-Step: A Fully Local Agent Team In Claude Code
Ollama exposes an Anthropic-compatible API, so Claude Code can run entirely on a local model, as described in Ollama's Claude Code integration guide.
On a 64 GB Mac, the whole team can run on the 8-bit version of Qwen3.8-27B.
| Agent | Model | Job |
|---|---|---|
| Lead (your session) | qwen3.8:27b-q8_0 (local) | Plans the refactor and integrates the changes |
refactorer | Same local model | Restructures the module without changing behaviour |
test-writer | Same local model | Writes tests that pin down current behaviour |
reviewer | Same local model | Reviews the final diff, read-only |
Step 1. Install Ollama, which runs local models and serves them over a local API.
bash
Code:
# Linux install script; on macOS, download the Ollama app from ollama.com instead
curl -fsSL https://ollama.com/install.sh | shStep 2. Optionally raise the GPU memory limit on your 64 GB Mac so the model and its context have more room, keeping at least 10 GB free for macOS.
bash
Code:
# Lets the GPU use up to 54 GB (55296 MB) of unified memory until the next reboot
sudo sysctl iogpu.wired_limit_mb=55296Step 3. Start the Ollama server with a 64K context window, which Ollama recommends for Claude Code, and allow two requests at once so two agents can work in parallel.
bash
Code:
export OLLAMA_CONTEXT_LENGTH=65536 # Claude Code needs a large context window to work well
export OLLAMA_NUM_PARALLEL=2 # two agents can run concurrently; drop to 1 under memory pressure
ollama serveStep 4. In a second terminal, download the 8-bit model that the whole team will share.
bash
Code:
ollama pull qwen3.8:27b-q8_0 # about 30 GB; leaves roughly 18-24 GB for context on a 64 GB MacStep 5. Create the three worker agents, each set to inherit the session's local model.
bash
Code:
mkdir -p .claude/agents
# Agent 1: refactorer — may edit only the target module
cat > .claude/agents/refactorer.md <<'EOF'
---
name: refactorer
description: Restructures src/billing/ for readability without changing behaviour.
model: inherit # use the same local model as the lead session
tools: Read, Edit, Bash
---
Refactor only files under src/billing/. Never change public signatures or behaviour.
EOF
# Agent 2: test-writer — writes characterisation tests before and after the refactor
cat > .claude/agents/test-writer.md <<'EOF'
---
name: test-writer
description: Writes tests that capture the current behaviour of src/billing/.
model: inherit
tools: Read, Write, Bash
---
Write tests under tests/billing/ that pin down current behaviour. Run them and report results.
EOF
# Agent 3: reviewer — read-only final check
cat > .claude/agents/reviewer.md <<'EOF'
---
name: reviewer
description: Reviews the diff for behaviour changes and weak tests. Read-only.
model: inherit
tools: Read, Bash
---
Compare the branch with main. List any behaviour change or weak test, most severe first.
EOFStep 6. Point Claude Code at Ollama, switch off non-essential network traffic, and start the lead session on the local model.
bash
Code:
export ANTHROPIC_BASE_URL=http://localhost:11434 # Ollama's Anthropic-compatible endpoint
export ANTHROPIC_AUTH_TOKEN=ollama # required by the client, ignored by Ollama
export ANTHROPIC_API_KEY="" # make sure no cloud key is used
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 # turn off telemetry and other optional calls
claude --model qwen3.8:27b-q8_0Step 7. Give the lead one instruction that runs the whole team.
text
Code:
First use test-writer to capture the current behaviour of src/billing/.
Then use refactorer to restructure the module while those tests stay green.
Finally use reviewer, and fix every issue it reports.Step 8. Confirm the work with
git diff and your test suite, and run ollama ps to see which model is loaded and how much memory it is using.Estimated Bill
| Item | Assumption | Cost |
|---|---|---|
| Tokens | All four agents run locally | $0.00 |
| Electricity (64 GB Mac mini) | About 0.1 kW for 2 hours at $0.10–$0.20 per kWh | ≈ $0.02–$0.04 |
| Electricity (64 GB Mac Studio) | About 0.2 kW for 1.5 hours at the same rates | ≈ $0.03–$0.06 |
| Total | | Well under $0.10 |
The same team on cloud APIs would cost several dollars, as Section III showed, and every rerun would cost the same again.
Locally, a rerun costs a few cents of electricity, and that is what makes local models a genuine game-changer for anyone who wants to keep running costs low.
XVII. Best Local LLMs For Agentic Coding With a 64 GB Unified Memory Minimum
Sixty-four gigabytes is the floor for a real local agent team in 2026, not a luxury.
It is the smallest memory size that holds the best 27-billion-parameter coding models at 8-bit precision with room to spare, and it is the smallest size that keeps a lead model and a worker model loaded at the same time.
How To Budget 64 GB Of Memory
A model has to fit together with its working memory, not on its own, so plan your 64 GB with these rules in mind.
Start from about 48 GB, not 64 GB. macOS reserves roughly a quarter of unified memory by default, and you can raise the GPU's share to about 54 GB withsudo sysctl iogpu.wired_limit_mb=55296, as Step 2 of Section XVI showed.
Choose 8-bit weights where you can. On Ollama, Qwen3.8-27B is 18 GB at 4-bit and 30 GB at 8-bit, according to its Ollama tag list, and 64 GB is what makes the higher-quality version practical.
Reserve memory for context and parallel agents. The KV cache grows with context length and with every parallel agent, so a 64K context for two or three agents can take many gigabytes on top of the weights.
Keep two models loaded when the team needs them. SettingOLLAMA_MAX_LOADED_MODELS=2lets a lead model and a worker model stay resident together, so Ollama does not have to swap them in and out between turns.
Mixture-of-experts models trade quality for speed. A model with about 3 billion active parameters generates tokens much faster than a dense model, while dense models usually score higher per gigabyte of memory.
The Shortlist
All scores below are coding results published by each model's maker or reported in the source linked beside it.
SWE-bench Verified and SWE-bench Pro are different, non-comparable benchmarks, so compare scores only within the same benchmark, and always test on your own code before you commit.
If you take one thing away from this section - create your own benchmark from your codebase, and verify your local model with that.
| Rank | Model | Maker | Type | Ollama Tag And Size | Context | Published Coding Score |
|---|---|---|---|---|---|---|
| 1 | Qwen3.8-27B | Alibaba Qwen | Dense, 27B | qwen3.8:27b-q8_0, 30 GB | 256K | SWE-bench Pro 61.7; Terminal-Bench 2.1 73.0 |
| 2 | Qwen3.6-27B | Alibaba Qwen | Dense, 27B | qwen3.6:27b-q8_0, 30 GB | 256K | SWE-bench Verified 77.2 |
| 3 | Qwen3.6-35B-A3B | Alibaba Qwen | MoE, 35B total, 3B active | qwen3.6:35b-a3b-q8_0, 39 GB | 256K | SWE-bench Verified 73.4 |
| 4 | Laguna XS 2.1 | Poolside | MoE, 33B total, 3B active | laguna-xs-2.1:q8_0, 36 GB | 256K | No score in the sources I checked |
| 5 | Muse Glimmer 30B | Meta | Dense, 30B | muse-glimmer, about 17 GB at 4-bit | 128K | SWE-bench Verified 76.0 |
| 6 | Devstral Small 2 | Mistral AI | Dense, 24B | devstral-small-2:24b, 15 GB | 256K | SWE-bench Verified 68.0 |
Two popular models do not make this list for a simple reason: they do not fit.
OpenAI's gpt-oss-120b is 65 GB on Ollama and Qwen3.5-122B-A10B is 81 GB, both above a 64 GB Mac's GPU budget, so they need a machine with more than 64 GB of unified memory.
What Each Model Is Best At
1. Qwen3.8-27B — the best overall lead agent. Its official model card reports 61.7 on SWE-bench Pro, well ahead of Qwen3.6-27B's 53.5, under an Apache 2.0 licence with a 256K native context. At 8-bit it uses about 30 GB, which leaves comfortable room on a 64 GB Mac for context and a second agent.
2. Qwen3.6-27B — the proven dense alternative. Its official model card lists 77.2 on SWE-bench Verified and 59.3 on Terminal-Bench 2.0, and it has months of community testing behind it. Use it when you want a well-understood model with the same memory footprint as Qwen3.8-27B.
3. Qwen3.6-35B-A3B — the fastest serious worker. With only 3 billion of its 35 billion parameters active per token, its official model card shows 73.4 on SWE-bench Verified at far higher speed than the dense models. At 8-bit it takes 39 GB, so on 64 GB it works best either alone or at 4-bit (24 GB) alongside a lead model.
4. Laguna XS 2.1 — the agentic specialist. Poolside released this 33B-total, 3B-active mixture-of-experts model on 2 July 2026, built specifically for agentic coding, as OpenSourceForU reported in its coverage of Poolside's Laguna models. Its 8-bit build is 36 GB on the Ollama Laguna XS 2.1 page, under the OpenMDW-1.1 licence. I could not find a published benchmark score, so my confidence in it is moderate and it is best treated as promising rather than proven.
5. Muse Glimmer 30B — the long-session alternative. DataCamp's overview of Meta's Muse Glimmer reports 76.0 on SWE-bench Verified and an Apache 2.0 licence. It trails the Qwen models on terminal tasks, so use it where long, multi-step agent sessions matter more than shell work.
6. Devstral Small 2 — the lightweight repository specialist. Mistral's Devstral 2 announcement lists 68.0 on SWE-bench Verified and a 256K context window for this 24-billion-parameter model. At 15 GB it is the easiest model here to pair with another, which makes it a good scout or test runner in a two-model team.
Again, run your own benchmarks, with your own code.
I commit to writing an article on that in the near future!
Step-By-Step: A Two-Model Security-Audit Team In OpenCode
This is the setup that 64 GB makes possible and 32 GB does not: a strong dense model leads and verifies, while a fast mixture-of-experts model does the parallel reading.
| Agent | Model | Job |
|---|---|---|
| Build (primary) | qwen3.8:27b at 4-bit, 18 GB | Splits the audit and writes the final report |
sec-scout × 3 | qwen3.6:35b-a3b at 4-bit, 24 GB | Audits authentication, input handling, and dependencies, read-only |
sec-verifier | qwen3.8:27b (shared with the lead) | Re-checks every finding against the code, read-only |
Step 1. Raise the GPU memory limit, then download both models, which together take about 42 GB.
bash
Code:
sudo sysctl iogpu.wired_limit_mb=55296 # about 54 GB for the GPU, at least 10 GB left for macOS
ollama pull qwen3.8:27b # lead and verifier, about 18 GB at 4-bit
ollama pull qwen3.6:35b-a3b # fast scouts, about 24 GB at 4-bitStep 2. Start Ollama so both models can stay loaded at once, with three parallel slots and a moderate context.
bash
Code:
export OLLAMA_MAX_LOADED_MODELS=2 # keep the lead and the worker model resident together
export OLLAMA_NUM_PARALLEL=3 # three scouts at once; lower this if memory runs short
export OLLAMA_CONTEXT_LENGTH=32768 # 32K per request keeps the KV cache inside the budget
ollama serveStep 3. Register both local models in the project's
opencode.json, using Ollama's OpenAI-compatible endpoint.json
Code:
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"ollama": {
"npm": "@ai-sdk/openai-compatible",
"name": "Ollama (local)",
"options": { "baseURL": "http://localhost:11434/v1" },
"models": {
"qwen3.8:27b": { "name": "Qwen3.8 27B (local lead)" },
"qwen3.6:35b-a3b": { "name": "Qwen3.6 35B-A3B (local workers)" }
}
}
}
}Step 4. Create the
sec-scout agent on the fast worker model, which the Build agent will call three times with three different scopes.bash
Code:
mkdir -p ~/.config/opencode/agents
cat > ~/.config/opencode/agents/sec-scout.md <<'EOF'
---
description: Read-only security scout. Audits ONE area of the codebase and lists concrete findings.
mode: subagent
model: ollama/qwen3.6:35b-a3b # fast MoE model for parallel reading
permission:
edit: deny # scouts never change code
bash: deny
---
Audit only the area you are given. For each finding return: file:line, severity, and a one-line explanation.
EOFStep 5. Create the
sec-verifier agent on the stronger lead model, so a different model checks the scouts' work.bash
Code:
cat > ~/.config/opencode/agents/sec-verifier.md <<'EOF'
---
description: Re-checks security findings against the source code. Read-only.
mode: subagent
model: ollama/qwen3.8:27b # the stronger dense model verifies the faster model's findings
permission:
edit: deny
bash: deny
---
For each finding, confirm or reject it with evidence from the code. Return only confirmed findings.
EOFStep 6. Start
opencode, use /models to select qwen3.8:27b for the Build agent, and give it one instruction.text
Code:
Call @sec-scout three times in parallel: one for authentication and sessions,
one for input validation and injection risks, and one for dependencies and secrets.
Pass all findings to @sec-verifier. Write the confirmed findings to SECURITY-AUDIT.md,
grouped by severity, with a suggested fix for each.Step 7. Run
ollama ps while the audit runs to confirm that both models are loaded and that memory use stays within your budget.Estimated Bill
| Item | Assumption | Cost |
|---|---|---|
| Tokens | Five agents on two local models | $0.00 |
| Electricity | About 0.1–0.2 kW for 1 hour at $0.10–$0.20 per kWh | ≈ $0.01–$0.04 |
| Total | | A few cents |
My Recommended Setups For 64 GB
Best quality: Qwen3.8-27B at 8-bit for every agent, with two parallel slots and a 64K context.
Best speed: Qwen3.6-35B-A3B for every agent, at 8-bit when it runs alone or at 4-bit when you want three or more parallel slots.
Best two-model team: Qwen3.8-27B as the lead and verifier, with Qwen3.6-35B-A3B or Devstral Small 2 running the worker agents.
Best agentic experiment: Laguna XS 2.1 at 8-bit, tested against Qwen3.8-27B on a few of your own tasks before you switch.
Best hybrid: a cloud model as the lead in OpenCode, with Qwen3.6-35B-A3B running every local worker agent.
Sixty-four gigabytes of memory, a free harness, and an open-weight model now add up to a genuine two-model coding team that costs cents to run.
If your work grows beyond that, a machine with more unified memory is the natural next step.
Buy the largest memory capacity you can afford within reason.
Your future self will thank you.
XVIII. Summary
Here is the whole article on one screen, with every task, team size, and rough bill side by side.
The last two rows assume a 64 GB Mac, which this article treats as the minimum for local agent teams.
| Platform | Perfect Task | Agents | Rough Bill |
|---|---|---|---|
| Claude Code | Full-stack feature build | 5 | ≈ $5.10 |
| OpenAI Codex | Parallel test-coverage sweep | 5 | ≈ $6.55 |
| xAI Grok Build | Competing landing-page prototypes | 5 | ≈ $2.36 |
| Google Antigravity | Legacy monorepo map | 5 | ≈ $8.00 |
| GitHub Copilot | 12-package dependency upgrade | 15 | ≈ $6.40 |
| OpenCode | Full API documentation | 7 | ≈ $1.85 |
| Pi | Four-language localisation | 5 | ≈ $1.20 |
| DeepSeek (inside Claude Code) | 200-file type-hint migration | 5 | ≈ $1.70 off-peak |
| Claude Code + Ollama (64 GB Mac) | Confidential refactor, fully local | 4 | A few cents |
| OpenCode + Ollama (64 GB Mac) | Two-model security audit, fully local | 5 | A few cents |
The Method In Five Points
1. Set the budget before you set the task.
2. Let one lead agent plan, let cheap worker agents explore, and let the lead integrate the results.
3. Route every subtask to the cheapest model that can do it well—and if you go local, start at 64 GB of unified memory.
4. Verify everything with a different model, a test suite, or a human reviewer.
5. Add another agent only when you can name the specific reason for it.
I strongly believe that AI agent orchestration is the most important developer skill of 2026.
It matters more than prompting tricks and far more than vibe coding, because it turns one developer into the conductor of a small, tireless team.
Keep one cloud frontier model like Claude on a low subscription for planning.
Run the majority of the work locally with your local LLM, unless you are doing research or frontier engineering, in which case a $200 USD subscription to Claude will earn its keep.
So plan your work, delegate it precisely, verify the results, merge with confidence, and repeat the cycle every day.
Then run
/usage—or ollama ps—and check what it cost, because a conductor who ignores the meter does not keep the orchestra for long.Finally, if you are choosing a skill to master this year - choose AI agent orchestration, in a field where you are already deep.
The breakthrough technology of the next few years will be AI Agent engineering.
I found some courses for that which I cannot help sharing because I want to get the best information and updates for my readers!
Why?
They are free to learn, are given by industry leaders, and gives you hands-on experience with AI agents.
Given below:
XIX. Free Courses for AI Agent Orchestration
All courses below are free.
Beginner
1. Microsoft: AI Agents for Beginners
https://github.com/microsoft/ai-agents-for-beginners
An open-source course on GitHub covering tool use, agentic RAG, planning, multi-agent systems and metacognition. The code runs on GitHub Models, which is free with usage limits. It’s the gentlest starting point.
2. Kaggle and Google: 5-Day AI Agents Intensive (2025 edition)
https://www.kaggle.com/learn-guide/5-day-agents
More than 1.5 million learners took the November 2025 live run, and it’s now a self-paced Kaggle Learn Guide. Each day pairs a whitepaper and podcast with code notebooks. You need a free Kaggle account.
3. Hugging Face: AI Agents Course
https://huggingface.co/learn/agents-course
It goes from first principles through three frameworks (smolagents, LangGraph and LlamaIndex) to a final agent you benchmark on a leaderboard. The certificate is free and is awarded for completing the capstone.
Intermediate
4. Kaggle and Google: 5-Day AI Agents, Intensive Vibe Coding (2026 edition)
https://www.kaggle.com/learn-guide/5-day-agents-vibecoding
The June 2026 follow-up to course 2. It covers multi-agent systems, memory and skills, security, and turning prototype agents into a managed, monitored production setup. You need free Kaggle and Google AI Studio accounts. The capstone and cloud-deployment exercises are optional and may need a Google Cloud account with billing enabled, so skip those to stay at zero cost.
5. Microsoft: MCP for Beginners
https://github.com/microsoft/mcp-for-beginners
An open-source course on the Model Context Protocol (MCP), with examples in .NET, Java, TypeScript, JavaScript, Rust and Python. MCP is how agents in an orchestrated system reach tools and data. It also covers security risks such as prompt injection.
6. Hugging Face: MCP Course
https://huggingface.co/learn/mcp-course
Built with Anthropic, it takes you from MCP basics to a deployed MCP application, with a free certificate. It goes deeper than course 5 on building real servers.
7. LangChain Academy: Introduction to LangGraph
https://academy.langchain.com/courses/intro-to-langgraph
Free, with 55 lessons and 6 hours of video covering state, memory, human-in-the-loop, parallel branches, sub-graphs, map-reduce and long-term memory. It’s the most hands-on course here on orchestration as explicit graphs. The notebooks default to OpenAI models, which bill per use; you can swap in a free model such as Gemini on Google AI Studio’s free tier or a local model through Ollama.
Advanced
These three are free recorded lecture series from UC Berkeley, taught by researchers. They explain why orchestration designs work rather than how to code them.
8. UC Berkeley: LLM Agents MOOC (Fall 2024)
https://llmagents-learning.org/f24
The first course in the series: LLM foundations, reasoning, planning and tool use, agent infrastructure, retrieval, and multimodal agents.
9. UC Berkeley: Advanced LLM Agents MOOC (Spring 2025)
https://rdi.berkeley.edu/adv-llm-agents/sp25
Builds on course 8 with reasoning, AI for mathematics, code generation and program verification. Lectures include reasoning, memory and planning in language agents, coding agents, and multimodal autonomous agents.
10. UC Berkeley: Agentic AI MOOC (Fall 2025)
https://agenticai-learning.org/f25
The newest course in the series, with guest lecturers from OpenAI, Google DeepMind, NVIDIA, Microsoft, Stanford and Sony AI. Lectures include Multi-Agent AI by Noam Brown (OpenAI) and agent safety and security by Dawn Song.
Suggested order: 1, then 3, then 5 and 6 for tool integration, 7 for hands-on orchestration, 4 for production, and 8 to 10 for the research view if necessary.
Take at least three courses, upskill, and practice with open-source repositories.
Make videos of your AI agent orchestration learning.
And; with some six months of hard dedicated work and open-source repositories of your own -
The recruiters will be calling you for a $500K+ USD role!
All the very best to you and your future career!
Cheers!
References
1. Lightcast data reported by IT Brew — https://www.itbrew.com/stories/ai-orchestrators-are-the-newest-in-demand-ai-role
2. How Anthropic built its multi-agent research system — https://www.anthropic.com/engineering/multi-agent-research-system
3. Anthropic: Building effective agents — https://www.anthropic.com/engineering/building-effective-agents
4. Claude Code overview and installation docs — https://code.claude.com/docs/en/overview
5. Manage Claude Code costs effectively — https://code.claude.com/docs/en/costs
6. Dynamic workflows in Claude Code announcement — https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code
7. Claude plans and API pricing — https://claude.com/pricing
8. OpenAI Codex CLI documentation — https://learn.chatgpt.com/docs/codex/cli
9. OpenAI Codex pricing and usage limits — https://learn.chatgpt.com/docs/pricing
10. Jetadmin: Codex pricing and realistic budgets 2026 — https://www.jetadmin.io/blog/codex-pricing-current-costs-usage-limits-and-realistic-budgets-2026/
11. Codesota Terminal-Bench 2.0 leaderboard — https://www.codesota.com/browse/agentic/autonomous-coding/terminal-bench-2
12. xAI official news timeline — https://x.ai/news
13. Grok Build getting-started documentation — https://docs.x.ai/build/overview
14. Ry Walker research note on Grok Build — https://rywalker.com/research/grok-build
15. Google: transitioning Gemini CLI to Antigravity CLI — https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/
16. Antigravity CLI getting-started documentation — https://antigravity.google/docs/getting-started?tab=cli
17. Claude Academy free courses — https://academy.claude.com/
18. GitHub Copilot CLI getting-started guide — https://docs.github.com/en/copilot/how-tos/copilot-cli/cli-getting-started
19. GitHub docs on the /fleet command — https://docs.github.com/en/copilot/concepts/agents/copilot-cli/fleet
20. GitHub Copilot plans and AI credits — https://github.com/features/copilot/plans
21. OpenCode getting-started documentation — https://opencode.ai/docs
22. OpenCode agents and subagents documentation — https://opencode.ai/docs/agents
23. OpenCode Zen pricing documentation — https://opencode.ai/docs/zen
24. Pi official website and documentation — https://pi.dev
25. DeepSeek API models and pricing — https://api-docs.deepseek.com/quick_start/pricing
26. DeepSeek Anthropic-compatible API guide — https://api-docs.deepseek.com/guides/anthropic_api
27. Caixin: DeepSeek V4-Pro launch and price rises — https://www.caixinglobal.com/2026-0...-api-prices-by-as-much-as-1100-102474222.html
28. Cognition: Don't Build Multi-Agents essay — https://cognition.ai/blog/dont-build-multi-agents
29. Ollama's Claude Code integration guide — https://docs.ollama.com/integrations/claude-code
30. Qwen3.6-27B official model card — https://huggingface.co/Qwen/Qwen3.6-27B
31. Qwen3.6-35B-A3B official model card — https://huggingface.co/Qwen/Qwen3.6-35B-A3B
32. DataCamp overview of Meta's Muse Glimmer — https://www.datacamp.com/blog/muse-glimmer
33. Mistral: Devstral 2 and Vibe CLI announcement — https://mistral.ai/news/devstral-2-vibe-cli/
34. LLM Configurator: raising the Metal memory limit — https://llmconfigurator.com/en/guides/troubleshooting/increase-metal-vram-limit-apple-silicon
35. AppleInsider: M5 Pro versus M4 Pro Mac mini — https://appleinsider.com/articles/2...m4-pro-mac-mini-compared-specs-hardware-price
36. Qwen3.8-27B official model card — https://huggingface.co/Qwen/Qwen3.8-27B
37. Ollama: Qwen3.8 tags and sizes — https://ollama.com/library/qwen3.8/tags
38. OpenSourceForU: Poolside's open-weight Laguna models — https://www.opensourceforu.com/2026/07/poolside-ai-launches-open-weight-laguna-coding-models/
39. Ollama: Laguna XS 2.1 model page — https://ollama.com/library/laguna-xs-2.1
40. MacRumors: Apple's June 2026 price increases — https://www.macrumors.com/2026/06/25/apple-just-increased-prices/
41. TrendForce: 3Q26 DRAM contract price forecast — https://www.trendforce.com/presscenter/news/20260709-13140.html
42. AI PMs are paid $500K plus at top companies — https://www.linkedin.com/posts/productfaculty_an-ai-pm-is-not-paid-500k-to-use-ai-share/
43. microsoft/ai-agents-for-beginners: Microsoft’s free open-source course on agent basics, tool use, planning and multi-agent design, with Python samples that run on GitHub Models’ free tier.
44. Google blog: AI Agents Intensive recap: Google’s recap of the November 2025 agents intensive, which links to the free self-paced Kaggle Learn Guide version.
45. Kaggle: 5-Day AI Agents Intensive Vibe Coding: The June 2026 edition, now self-paced, covering multi-agent systems, memory, security and moving agents into production.
46. Hugging Face Agents Course: A free certified course that goes from agent fundamentals through smolagents, LangGraph and LlamaIndex to a benchmarked capstone agent.
47. Hugging Face MCP Course: A free certified course, built with Anthropic, that takes you from MCP basics to a deployed MCP application.
48. microsoft/mcp-for-beginners: Microsoft’s open-source MCP course with server and client examples in .NET, Java, TypeScript, JavaScript, Rust and Python.
49. LangChain Academy: Introduction to LangGraph: A free 55-lesson course on building stateful single-agent and multi-agent workflows with LangGraph.
50. Berkeley RDI: Advanced LLM Agents (Spring 2025): Free recorded Berkeley lectures on agent reasoning, planning, coding agents and multimodal agents.
51. Berkeley RDI: Agentic AI (Fall 2025): Berkeley’s latest free lecture series on designing, evaluating, deploying and securing agentic systems, with speakers from OpenAI, Google DeepMind and NVIDIA.
The Digital Futurist · https://thomascherickal.com · https://thomascherickal.github.io