The Orchestrator Was Fine. The Limbs Misfired.
Evidence for the better-trained-limbs thesis: my content pipeline's orchestrator was solid; the limbs are where it broke.
A while back I wrote a post about drumming and agent systems — that the goal is probably better-trained limbs, not a smarter orchestrator. I just got a clean piece of evidence for that.
For the last month I’ve been building a small content pipeline. The job: ingest a GitHub repo, decide if I already have a domain expert who can write about it, and if not, mint a new one. There’s a router at the top that makes the routing call, a synthesizer that drafts the new content, and a merge step that splices the draft into a longer briefing document. Three moving parts. The router is the orchestrator. The synthesizer and the parser are limbs.
Round 1 of validation, a few days ago, found four bugs. I read them as orchestrator bugs — wrong routing decisions, wrong arguments getting passed, a destructive write. I shipped fixes for all four.
Round 2, this week, I ran the whole thing again on a fresh repo to see if the fixes held.
The orchestrator is solid. Routing fires correctly. The right slug threads through the right call. The mechanical shortcut I built for “I’ve seen this domain before” actually skips the expensive LLM call now — zero re-prompts on the second pass. That’s the kind of thing that’s almost boring to verify, which is what you want.
The limbs are where it broke.
The synthesizer drafted content in a format the merger couldn’t parse. Not because it was wrong — because nobody told it the exact format. It guessed. The merger refused to splice and saved the draft for me to hand-fix.
The parser, when it did get good input, was a little too eager. It kept ingesting lines past the end of the actual content, picking up commentary I’d added at the bottom and treating it like more of the same. The output looked right at first glance and was subtly polluted.
The registry, on the third pass, hadn’t caught up to a brand-new persona that had been minted seconds earlier in the same session. The orchestrator tried to call it, the registry shrugged, the call failed.
None of these are orchestrator bugs. The router did exactly what I told it to. The limbs aren’t trained on the specific signals they’re now being asked to respond to.
That’s the whole thing, again. You can have a perfectly conducted band and still sound bad if the players don’t know the song. The fixes I’m shipping next aren’t to the orchestrator. They’re three small notes: teach the synthesizer the format, tell the parser when to stop, give the orchestrator a fallback when the registry is slow.
Better-trained limbs. Still true.