Skip to main content
A flat Swiss-style geometric poster: two abstract figures — a teal circle-topped column and an emerald square-topped column — facing away from each other on a shared shelf of small document rectangles, a thin amber arc bridging them overhead, and between them two identical white rectangles, only one connected to the shelf

The Problem

I run two AI agents against the same markdown vault. A persistent desktop agent — I call it Dispatch, built on Claude Cowork — handles the standing work: morning intelligence briefs, deadline tracking, monitoring. Claude Code sessions handle the deep work: strategy docs, research, the harness itself. Both had been productive for weeks. Neither knew the other existed. Dispatch was reading stale facts; Claude Code was rediscovering things Dispatch already tracked daily.

The Approach

I asked Claude Code to audit both directions — what does each side produce that the other can’t see — and design the minimum bridge, with hard constraints carried over from an earlier audit of my own scaffolding: no shared state file, no handoff protocol, nothing both agents would have to co-maintain. The vault itself is the shared state; the bridge should just be facts about where each side’s outputs land, plus making the ephemeral outputs durable — the daily brief, for instance, was delivered as a chat message and saved nowhere.

What Happened

The audit surfaced real rot fast: the morning brief was still prioritizing email from an exec who’d left the company seven months earlier, and two of its file pointers had died when I reorganized folders in June. Claude fixed both in the skill files sitting in the vault, wrote up the design, and everything looked shippable. Before saying go, I asked one question: did you actually check the product docs for how Cowork works, or did you design this from what you found in my files? It hadn’t. The docs said scheduled-task definitions load from a hardcoded folder in ~/Documents — not from the vault. We looked: the folder existed, the files in it were byte-identical to the vault copies except for one thing — Claude’s fixes weren’t in them. stat settled it: different inodes. The vault copies were mirrors someone (me, probably) had copied out weeks ago. The fixes had shipped to files the agent would never read. Claude redesigned it: the hardcoded files became thin shims — “read the canonical procedure in the vault and follow it” — and the fixes went back in, this time to a file the agent actually reads.

What I Learned

Watching the system’s outputs told Claude plenty about what it does, and nothing about where it reads its instructions from — that part was only in the docs. It built a correct design on one wrong assumption it couldn’t detect empirically, and the fix cost one question. That question is now standing practice for any integration with an external runtime: before wiring into it, confirm where it actually loads its configuration from.
Drafted by my Claude from our working session. I approved it before it went up.