The DeepSeek harness uses 9 specialised sub-agents instead of one giant model, and that single architecture choice is why it quietly beats Claude Code on real multi-file work.
I've been running this thing in production for a fortnight and the more I dig into the internals, the more impressed I get.
If you've ever wondered why one AI coder ships clean diffs while another rewrites half your codebase by mistake, the answer is sub-agent specialisation.
Let me show you what's actually happening under the bonnet.
Why the DeepSeek harness architecture matters
Most AI coding agents are one big model in a loop.
You give it a task, it tries to do everything — read files, plan, edit, test, review — all from the same brain.
That works for tiny tasks.
It falls apart on anything that touches more than a couple of files.
The DeepSeek harness takes the opposite approach.
It breaks the work into nine specialised sub-agents, each with a narrow job and a tuned model behind it.
The result is fewer rabbit holes, cleaner diffs and faster output on multi-file work.
This is the same architectural pattern I've covered in Claude Hermes agent and Hermes agent OS — different systems, same principle.
Install the DeepSeek harness in 30 seconds
Before we go deep, here's the install in case you want to follow along.
npm install -g freebuff
cd your-project
freebuff
Three lines, no card, no API key, no signup.
The harness ships as the FreeBuff CLI from the CodeBuff team — they monetise the paid parent product and offer FreeBuff with text ads in the terminal.
That's the whole business model.
Now the deep dive.
Want my full DeepSeek harness deep dive video + prompt pack? Inside the AI Profit Boardroom, I've recorded the full sub-agent walkthrough plus the prompts I use to drive each one specifically. Get access here
The 4 main coding models inside the DeepSeek harness
Before we talk about the sub-agents, you need to know which models they're calling.
The harness lets you pick from four main coding brains.
| Model | Strength | Use case |
|---|---|---|
| DeepSeek V4 Pro | Strongest reasoning, multi-file logic | Complex feature work |
| Kimi K2.6 | Massive context window | Large codebase analysis |
| Miniax M2.7 | Cleaner front-end + creative output | UI and design work |
| DeepSeek V4 Flash | Fastest and cheapest | Quick edits and chat |
You can swap models mid-session.
That alone is more flexibility than Claude Code or Cursor give you on their default plans.
For deeper coverage of the model lineup, my DeepSeek V4 tutorial goes wider.
Sub-agent 1 — The file picker
The file picker is the first sub-agent to run on any task.
Its job is to scan your codebase and pull only the files relevant to the request.
That sounds simple — it's not.
Claude Code and Cursor often grab too many files and dilute the context.
The DeepSeek harness file picker is narrower by design.
It uses Gemini 3.1 Flash Lite (cheap, fast, surprisingly accurate for retrieval) to score files against your prompt and only pull the top matches.
The effect is sharper output because the main coding model sees less noise.
When you use the @filename syntax in your prompt, you're directly hinting to the file picker.
That's the highest-leverage tip in the whole tool.
Sub-agent 2 — The code reviewer
The code reviewer runs after every change.
Its job is to review the diff and flag risky edits before they ship.
This is the sub-agent that quietly saves you from production bugs.
I had it catch a regression I hadn't even reported during a bug fix session last week.
The reviewer sub-agent is one of the reasons the DeepSeek harness beats Claude Code on real multi-file work.
Claude Code is one model trying to write AND review at the same time.
A separate reviewer with a separate context window catches more.
I cover the same review pattern in DeepSeek SEO for a different use case.
Sub-agent 3 — The browser-use sub-agent
The browser-use sub-agent opens a real browser and tests what the harness builds.
Not a headless test runner — an actual Chromium instance with a visible page.
It clicks, scrolls, fills forms, takes screenshots and reads back what it sees.
This is where most "build me an app" demos break in lesser tools.
The agent builds something that looks fine in the diff but doesn't actually work when rendered.
The browser-use sub-agent catches that gap.
It's the closest thing to a free QA engineer I've used.
For a comparable browser-use approach, see OpenClaw computer use on a different stack.
Sub-agent 4 — The planner
The planner runs when you type /in to launch interview mode.
Its job is to ask you 5-7 questions about scope, acceptance criteria and edge cases before any code gets written.
This is the single highest-ROI sub-agent in the whole harness.
Most people skip the interview command and the agent guesses at scope.
That's how you end up with three rounds of "actually I meant…".
A 90-second interview at the start saves an hour of rework at the end.
The planner is also responsible for breaking a big task into ordered steps so nothing gets skipped.
Sub-agent 5 — The editor
The editor is the sub-agent that actually writes the diffs.
It runs after the planner has scoped the task and the file picker has gathered context.
Its specialisation is precise surgical edits instead of rewriting whole files.
This matters more than people realise.
A single-model agent like Cursor often rewrites a whole file when it only needs to change three lines.
That rewrite is where formatting drift and silent bugs sneak in.
The editor sub-agent in the DeepSeek harness uses tight diff windows and only touches the lines that need to change.
Cleaner git history, fewer merge conflicts, less drift.
Sub-agent 6 — The researcher
The researcher uses Gemini 3.1 Flash Lite for web research.
When the main coding model needs context from outside the codebase — docs, library APIs, version changes — the researcher fetches it.
This is the sub-agent that makes the harness feel like a connected developer rather than a sandboxed model.
Need the latest Stripe webhook docs mid-build?
The researcher pulls them, summarises the relevant bits and feeds them into the main coder.
You don't have to context-switch to your browser, copy-paste docs and lose your flow.
For comparable research-while-coding patterns, see auto research claw.
Sub-agent 7 — The terminal runner
The terminal runner executes shell commands and reads back the output.
Need to run tests, check a build, install a dependency or fire up a dev server?
The harness can do all of it without leaving the agent loop.
It runs commands, parses the output, and feeds errors back into the main coder so it can fix them automatically.
The first time I watched it run npm test, read a failure, fix the code and re-run the tests until they passed, I genuinely laughed.
That's the kind of self-healing loop that justifies the whole architecture.
The terminal runner is also why the DeepSeek harness can run "build, test, fix, repeat" sessions without a human in the loop.
Sub-agent 8 — The deep thinker
The deep thinker is optional and needs a ChatGPT subscription to use.
It calls GPT 5.4 for the hardest reasoning problems — the ones DeepSeek V4 Pro can't quite crack.
You won't need it most days.
But when you're stuck on a gnarly algorithm problem or a tricky architecture decision, the deep thinker is there.
It's the escape hatch.
Honestly, for 90% of work you'll never invoke it.
But knowing it's available means the DeepSeek harness has a ceiling close to Opus 4.7 when you really need it.
Sub-agent 9 — The follow-up suggester
The follow-up suggester is the one most people don't notice but quietly adds the most velocity.
After every response, it drops three clickable next actions.
"Run the tests now."
"Add error handling to this function."
"Refactor this into a separate file."
You don't have to think about what's next — the suggester is already there with three options.
This is the sub-agent that turns the DeepSeek harness from a one-shot tool into a continuous flow.
I've covered the same flow-state pattern in chatgpt workspace agents for a different system.
How the 9 sub-agents work together
Here's a typical task flow.
- You type your request (or hit
/infor interview mode). - The planner asks clarifying questions if needed.
- The file picker scans the codebase and pulls relevant files.
- The researcher fetches any external docs needed.
- The editor makes the precise diffs.
- The terminal runner executes any commands.
- The browser-use sub-agent tests the result.
- The code reviewer reviews the diff and flags risks.
- The follow-up suggester offers three next actions.
That's a full development loop with nine specialists handling their lane.
A single big model trying to do all nine of those jobs in one prompt makes more mistakes than nine specialists doing one thing each.
That's not a clever theory — that's the actual reason the DeepSeek harness ships cleaner output than Claude Code on multi-file tasks.
For solo founders building real products, this matters a lot.
I cover the broader build-velocity stack in agentic AI OS.
Why this architecture is hard to replicate
You might think "I'll just chain prompts in Claude Code and get the same thing."
You can — but it's clunky.
The DeepSeek harness has the orchestration logic baked in.
Sub-agents have their own context windows so they don't pollute each other.
The harness manages handoffs between sub-agents automatically.
Each sub-agent uses the model best suited for its task (cheap models for retrieval, premium for reasoning).
You'd spend weeks building this yourself with raw API calls — and you'd pay for every prompt.
The CodeBuff team built it once, open-sourced it, and made it free.
That's a gift.
The trade-offs you should know about
I'm not going to pretend the DeepSeek harness is perfect.
Multi-agent systems have more moving parts, which means more places for things to go subtly wrong.
The browser-use sub-agent occasionally fumbles on heavy single-page apps with weird hydration.
The deep thinker requires a ChatGPT subscription, which breaks the "fully free" promise if you need it.
The terminal ads are unobtrusive but they exist.
And the model selection screen is one step you have to do every session.
None of these are dealbreakers.
But honesty matters.
If you need absolute top-tier reasoning every single prompt, Claude Code with Opus 4.7 is still the king.
For the other 95% of real-world work, the DeepSeek harness wins.
🔥 Want the prompt templates I use with each sub-agent? Inside the AI Profit Boardroom, I've shared the prompts that consistently produce shippable code from the DeepSeek harness — plus the sub-agent invocation tricks. → Get access here
My 5 tips for getting the most from the DeepSeek harness sub-agents
These took me a few sessions to learn.
Tip 1 — Always start with the interview command
Type /in and let the planner sub-agent ask questions first.
This single habit changes everything.
Tip 2 — Pin files with @filename mentions
Help the file picker by telling it exactly which files matter.
Less guessing equals sharper output.
Tip 3 — Match the model to the task
DeepSeek V4 Pro for serious work, Flash for quick edits, Miniax for UI, Kimi for big-context refactors.
The harness lets you switch mid-session — use that flexibility.
Tip 4 — Trust the code reviewer
Don't skip the reviewer's flags.
If it flags a risky edit, look at it before you ship.
Tip 5 — Treat each sub-agent like a team member, not a tool
Each one has a specialism.
Address them by what they do, not by generic prompts.
"Run the tests in @src/tests/auth.test.ts" works better than "check if it works."
Watch the AI Profit Boardroom walkthrough
Here's the bigger system this slots into.
DeepSeek harness architecture FAQ
How many sub-agents does the DeepSeek harness use
The DeepSeek harness uses nine specialised sub-agents — file picker, code reviewer, browser-use, planner, editor, researcher, terminal runner, deep thinker, and follow-up suggester.
What models power the DeepSeek harness sub-agents
The main coding sub-agents use DeepSeek V4 Pro, Kimi K2.6, Miniax M2.7 or DeepSeek V4 Flash — the file picker and researcher use Gemini 3.1 Flash Lite, and the optional deep thinker uses GPT 5.4.
Can I disable specific sub-agents in the DeepSeek harness
Some sub-agents can be skipped per task — for example you can ship a quick edit without invoking the code reviewer, though I don't recommend it for anything going to production.
Why is the DeepSeek harness multi-agent design better than Claude Code
Specialisation reduces context dilution — nine narrow sub-agents make fewer mistakes on multi-file tasks than one giant model trying to do everything at once.
Is the DeepSeek harness sub-agent system really free
Yes — the entire nine sub-agent system runs free with text ads in the terminal, no card, no trial, no cap.
How is the DeepSeek harness orchestration handled
The harness manages sub-agent handoffs automatically — you don't manually invoke each one, the planner and orchestration layer route your request through the right sequence.
About Julian
I'm Julian Goldie — AI entrepreneur, SEO expert, and founder of the AI Profit Boardroom (2,800+ members). I help business owners scale with AI agents, automation, and SEO.
- 282K+ YouTube subscribers
- 7-figure AI agency (Goldie Agency)
- Daily training inside the Boardroom
- Author of multiple AI automation playbooks
→ Get my best AI training inside the AI Profit Boardroom
Also On Our Network
- 🌐 Read on bestaiagentcommunity.com
- 🌐 Read on aiprofitboardroom.com
- 🌐 Read on juliangoldieaiautomation.com
- 🌐 Read on aimoneylabjuliangoldie.com
Related reading
- DeepSeek V4 tutorial
- Claude Hermes agent
- Hermes agent OS
- OpenClaw computer use
- Auto research claw
- Agentic AI OS
- AI Profit Boardroom
Want my best AI training
📺 Video notes + links to the tools 👉
🎥 Learn how I make these videos 👉
🆓 Get a FREE AI Course + Community + 1,000 AI Agents 👉
📞 Book a free strategy session with Goldie Agency 👉
The DeepSeek harness sub-agent architecture is the most interesting thing I've seen in AI tooling this year — install it and watch the nine specialists ship cleaner code than any single model.