A few months ago I had a passing thought about how MQTT QoS levels actually behave in practice. Normally that’s fifteen minutes of vague Googling, half an answer, and forgotten by dinner. Instead I typed it into Todoist.
By the time I checked back there was a research note in my vault: six sources tiered by credibility, a synthesis that named the actual tradeoffs, a Mermaid diagram of the three QoS handshakes, an Open Questions section flagging what nobody had pinned down. Five existing notes had picked up a backlink to it.
This is the pipeline that turns a one-line curiosity into that note. It’s the most expensive workflow in my homelab per invocation, and the one I’d defend the hardest.
What the workflow does
A research skill drives six agents in a fixed flow. A crawler gathers and tiers sources; a synthesizer drafts the note; a developmental editor gates the structure; then a copy editor, a validator, and a fact checker review in parallel before the synthesizer revises.
flowchart LR Q[Topic] --> CR[Crawler<br/>Sonnet — fetch + tier sources] CR --> SY[Synthesizer<br/>Opus — draft note] SY --> DE[Developmental editor<br/>Opus — structural gate] DE --> CE[Copy editor<br/>Opus] DE --> VA[Validator<br/>Opus] DE --> FC[Fact checker<br/>Sonnet — conditional] CE & VA & FC --> RV[Synthesizer — revise pass] RV --> N[Vault note + backlinks]
A few things the boxes don’t show. The crawler runs vault retrieval first and skips ground I’ve already written up, so the synthesizer doesn’t re-explain old notes. It tiers each source High, Established, or Weak with no pressure to make them fit a narrative — it doesn’t write the narrative.
The developmental-editor gate runs unconditionally and owns structure: one HIGH finding sends the note back for a structural revise before anything else. The fact checker is conditional — it fires only when a non-High source slips through or the synthesizer flags a cross-source contradiction. Each reviewer tags findings HIGH or LOW, and only a HIGH forces a change. Model pinning does quiet work here too: the retrieval-heavy stages run on Sonnet, the reasoning-heavy ones on Opus.
The orchestrator never writes the note. It dispatches, routes on severity, inserts backlinks, and reports; the synthesizer owns the file path and the orchestrator is forbidden to touch it. That separation is load-bearing. When one process both decides what to do and does it, the decision quietly drifts toward whatever was easy to do.
Why it isn’t just one agent
The honest answer: I tried one agent first, and it wasn’t good enough.
The monolith was a single Opus agent with a long prompt covering methodology, source evaluation, synthesis, writing, self-critique, and backlinks. It produced fine notes most of the time. The failure modes were the interesting part.
Its self-critique fixated on hygiene — frontmatter, stale headings, duplicated paragraphs — and almost never asked whether the conclusions were sound. It rarely surfaced cross-source contradictions, because by the time it reviewed its own work it had already smoothed them into one confident narrative. Source credibility wandered, because “be skeptical” was fighting “synthesize a coherent finding” inside the same prompt.
Splitting the work fixed all three. The crawler tiers sources without writing the narrative they’d have to fit. The synthesizer’s contradiction_flag is a structured output, not a prose hedge, so it actually trips the fact check. The critic is a separate agent with an adversarial prompt, not biased by having just written the thing. In fairness, the monolith never got the hardening the pipeline did — once I committed to the split, I stopped tuning it.
This is the same lesson as the SDLC pipeline: narrow scope, specialist agents, structured handoffs. When one prompt has to pull in two directions, the louder direction wins.
The cost
A full run is five to fifteen minutes of wall time, depending on how many sources the crawler accepts. The token cost is comfortably an order of magnitude above a single Sonnet call asking for “a research summary on X.”
I measured it once during the cutover. In Opus-equivalent units the pipeline ran about 1.4–1.8× the monolithic Opus version — not the 2–3× a raw token sum suggests, because model pinning keeps the retrieval stages on Sonnet. The developmental-editor gate landed as an unconditional Opus stage after that measurement, so 1.4–1.8× is now an understatement I haven’t remeasured. The cost is dominated by which stages you let Opus run, not by how many stages you have.
There’s a complexity cost too. The dispatch order, the severity routing, the conditional fact check, the backlink cap — every rule is there because a prior version drifted without it. It isn’t ceremony. It’s the contract that makes the pipeline behave the same way every time.
Why I pay it anyway
The notes are better.
That’s the short version, and it’s hard to expand without sounding hand-wavy. Here’s the concrete one: these notes survive being read again six months later. The sources are tiered, so I know which claims rested on real evidence and which were Reddit threads I took as Weak-tier color. The Open Questions section surfaces what the synthesis glossed over — the validator writes those. When there’s a diagram, it usually argues a point rather than restating one.
The monolith produced notes that looked like all of that and weren’t. The Open Questions were generic, the diagrams were org charts, the sources were five URLs that looked plausible. Fine to read once, useless on the second visit.
A second benefit took longer to notice. Because the pipeline is reliable, the threshold for asking it to research something collapsed. The capture cost is one Todoist task and the research cost is somebody else’s cron tick, so the “I wonder about X” notes pile up — and most turn out more useful than I expected.
The third I didn’t predict at all: the pipeline writes notes I can later research against. UPDATE mode reads the Key Findings, Open Questions, and source table from a prior note, runs the same pipeline against new sources, dates the new findings, and appends a revision row instead of rewriting. The notes are durable artifacts I revisit when the facts move. That alone has paid for the whole thing several times over.
When I skip it
Plenty of questions don’t need any of this. A syntax lookup, a “what’s the API for X,” a “which flag does Y” — those go to a normal chat. The pipeline earns its cost when the question is open enough to benefit from synthesis across sources and important enough that I’ll come back to it. “Are there good off-the-shelf Zigbee blueprints for the Aqara FP1?” is the right shape; “what’s the systemd syntax for restart-on-failure?” isn’t.
The rule I’ve settled on: if I’d have spent ten minutes on it by hand and wanted the result in the vault, the pipeline is worth it. Below that bar, the chat window is fine. The old awkward middle — five-to-ten-minute questions I’d either underinvest in or resent — is gone, because now I pay tokens instead of attention and the artifact lands either way.
The shape underneath
Every workflow that has stuck for me has the same skeleton: a focused entry point, a deterministic gather step in code, an LLM judgment step in the middle, and a landing place inside a surface I already check. The research pipeline is that skeleton with the judgment step blown out into six agents, because judgment was the part that needed the most help.
It replaced a single-agent design that produced acceptable work. Acceptable was the ceiling, and I wanted notes I could trust in six months. The cost is real and I think about it every time. The payoff is that I’ve stopped thinking about whether to invoke it — the answer is almost always yes.