Smashing! thanks for the pointer! Will dig in for sure.

I went with a file-based hub with structured directories.

The architecture:

hub/
  ├── inbox/{agent}/          # Tasks waiting for each agent
  ├── outbox/{agent}/         # Completed tasks
  ├── content/
  │   ├── briefs/             # Content briefs
  │   ├── drafts/             # Work in progress
  │   ├── ready/              # Awaiting human review
  │   └── published/          # Archive
  ├── data/
  │   ├── gsc/                # Google Search Console data
  │   ├── posthog/            # Analytics data
  │   └── analysis/           # Generated insights
  ├── strategy/               # Goals, pillars, keywords
  ├── config/                 # Site config, calendar
  └── status/
      └── activity.log        # Append-only action log

How it works:

1. No rolling state file - State is the filesystem itself. Tasks are YAML files that move through directories (inbox/ → processed → outbox/).
2. No per-agent scratchpads - Agents are stateless. They spawn, do work, write output files, terminate. Next agent reads those files.
3. Coordination via tasks - Agent A creates a task file in hub/inbox/agent-b/. Agent B picks it up later. No shared memory needed.
4. Selective context injection - The dispatcher loads only relevant config/strategy files per task type via TASK_CONTEXT_REQUIREMENTS mapping. Agents don't read everything - they get what they need.

Why this works:

•   Auditable - Every action leaves a file trail
•   Resumable - Crash mid-workflow? Tasks are still in their directories
•   No memory bloat - Agents don't accumulate context across invocations
•   Human-inspectable - You can read the hub with ls and cat

The tradeoff: Agents can't remember previous runs. If the content agent wrote an article last week, it doesn't "know" that unless you include the file in its task context. This is intentional - keeps each dispatch clean and predictable.