HomeTech Talk

I Gave the Router the Big Brain

DeepSeek keeps its router thin. I gave mine the strongest model, added an advisor, and let cheaper workers build. One real run, with the token numbers.

· 5 min read

  • Super-agent
  • DeepSeek
  • multi-agent
  • prompt caching
  • AI agents
  • agent architecture
On this page 7 sections

TL;DR

  • DeepSeek keeps its router thin. I gave mine the strongest model; cheaper workers build.
  • First production run: 33 tickets, 16 PRs, 329 files, 21 hours.
  • 99% of tokens came from cache (router 99.6%, workers 98.9%).
  • The router–advisor debate took just 18 minutes. The real waits: reviews, stalls, and a question I missed.
  • Next: a shorter router prompt, merge pre-approval, a stricter plan template.

On Monday I ran the framework on its first big job. My own input took under an hour: mostly design ideas, UX thinking and taste. I barely touched anything technical. In about 21 hours the agents worked 33 tickets, and 16 pull requests merged over two days (13 through the agents), touching 329 files.

  • 21 hstart to finish
  • 33tickets worked
  • 16pull requests merged
  • 329distinct files changed
  • 99.0%of input tokens came from cache

Two surprises: the token usage looked small, and the slow part wasn’t what I blamed.

Where I started: a thin router

DeepSeek has published a prototype of its Super-agent (I explained the idea ten days ago). Its router is deliberately thin. It forwards the request with a note of at most 30 words and must not add plans or acceptance criteria. Workers read the source and work it out. The goal, per the README: take as little human attention as possible.

That fits requests arriving all day. Mine is one person with one big job at a time. I’d rather wait for a good plan than review a bad pull request.

Where the strong model sitsDeepSeek's prototypeThin routerforwards the requestStrong workersplan and buildMy versionStrong routerwrites the plan, advisor attacks itstuck? ask backLighter workersbuild, then QA testsstrong modellighter modelWhere the strong model sitsDeepSeekThin routerforwards itStrong workersplan and buildMineStrong routeradvisor attacks itstuck? askLighter workersQA tests itstrong modellighter model
The strong model moves from the workers to the router.

The one thing I changed

I kept router-plus-workers and moved the strong model:

  1. The router, on the strongest model, reads the code and writes the plan.
  2. The advisor, a separate session, attacks it. At least two rounds.
  3. Lighter workers build the approved plan in their own git worktrees.
  4. An architect reviews each pull request. QA tests the real thing.
  5. A stuck worker sends the question back. The router decides.

Every plan answers five things: what to do and why, how we’ll know it’s done (a live check), which edge cases to test, what not to build, and when to ask instead of guessing.

Think of building a house: the architect draws the plans, a second one reviews them, then the crew builds. A worker with clear steps doesn’t need to be brilliant, just careful. The cost is speed: no quick chat with the router.

What happened in production

  • 33 tickets, nine plans, 23 advisor rounds. Small pull requests merged into one integration branch, then one final pull request into main.
  • Across 47 “ready” reports, workers asked 2 questions. Two blockers, both a billing problem.
  • The advisor caught real problems before any code: two tests that would have broken CI, a rollout that could ship a half-finished UI, a safety check that would have matched itself.
  • QA found two serious bugs the earlier reviews missed.

Here’s what weakens my thesis. Most workers started on the lighter model. After those two bugs, and my design feedback, the router moved every worker to the stronger one. By the end, two thirds of worker calls used it. The plan is what lets a lighter model work, and the bugs were holes in the plan.

The bill: 633 million tokens, 8 million of them fresh

Every model call re-sends the whole conversation. The provider caches the unchanged part and charges much less to read it.

The run made about 3,100 calls and processed 633M tokens. 625M were cache reads. The rest: 6K uncached input, 6.1M cache writes, and 1.93M output, 455K of it (24%) reasoning.

99% of tokens came from cache625M read from cache8M fresh633Mtokens processed99.6%router cache hits98.9%worker cache hits99% of tokens came from cache625M from cache8M fresh633Mtokens processed99.6%router cache hits98.9%worker cache hits
One run: tokens read from cache against fresh tokens.

With the prices I assumed (reads at a tenth of normal input, writes at twice), input cost roughly 8× less than without caching. That’s an assumption, not a dollar figure.

Why the router hits 99.6%

The prompt only grows at the end. The strong model writes the plan once, and advisor fixes are small edits. Over 391 calls the prompt grew from 93K to 547K tokens, about 1.25K new per call. It was never compacted, which would have thrown the cache away.

A timer keeps it warm. The wait tool wakes the router after 55 minutes. The cache lasts an hour, so it never expired, even overnight.

Nothing else changed the start of the prompt. Same model, tools and instructions throughout. After a restart, the first call still read 491K tokens from cache.

Drag the slider and look for the “wake-up” calls.

Replay the router, one call at a time

99.9%of this prompt came from cache

Prompt 547KNew this call 267

Drag back to call 1: the prompt grows from 92.8K to 547K tokens.

One real session: 391 calls, about 21 hours.

Workers hit 98.9% too; the few below 95% were short tickets that start cold. A high hit rate isn’t low usage, though: workers read 485M tokens, 3.5× the router.

Where the waiting went

I blamed the router and advisor arguing. The logs disagree.

The advisor was the smallest waitAdvisor debateAdvisor debate: 18 minutes18 minthe one I blamed12 architect reviews12 architect reviews: 144 minutes144 minPlan to first screenPlan to first screen: 282 minutes282 minRouter asked, I missed itRouter asked, I missed it: 515 minutes515 minThe advisor was the smallest waitAdvisor debate18 minAdvisor debate: 18 minutes12 architect reviews144 min12 architect reviews: 144 minutesPlan to first screen282 minPlan to first screen: 282 minutesRouter asked, I missed it515 minRouter asked, I missed it: 515 minutes
Measured waits, in minutes. They overlap.
  • The advisor’s median round took 30 seconds. All 23 rounds added up to 18 minutes.
  • Every pull request waited for a fresh architect session, then fixes, CI and merge. Twelve reviews took about 2.4 hours.
  • Twelve “gone quiet” alerts, and one worker type that never got its brief (an hour).
  • I saw the first working screen 4.7 hours in. My feedback started a second round that used about half the worker tokens.
  • The biggest wait was me. The router asked whether to delete a 306 MB preview folder. I didn’t see it, and answered about 8.5 hours later.

The agents were fast. The waiting was everything around them, including me.

What I’m changing next

  1. A shorter router prompt. Let default compaction run. At my assumed prices it pays for itself in about five calls.
  2. Merge pre-approval in the plan, and reviews that start when a worker reports “ready”, in parallel with CI.
  3. CI only where it matters. Done: none into the integration branch, a one-minute check on drafts into main.
  4. A stricter plan template that the command line enforces. The two QA bugs were plan gaps.
  5. Models per role, and a status command plus a phone ping when the router needs me, so I stop missing its questions.

What I don’t know: this is one run, with no dollar figure and no head-to-head against the thin router. Two QA bugs and two questions are a hint, not a result.

Summary

Put the strong model where the whole picture lives, make it write a plan a careful, cheaper worker can follow, and keep its prompt append-only and awake. The advisor wasn’t the slow part. The waiting hid around the agents, and sometimes in me, so that’s where I’ll work next.