The Multi-Agent Demo Lie
Every “multi-agent” demo you’ve seen follows the same script: three chatbots pass JSON to each other in a loop, somebody calls it “orchestration,” and the audience claps. Ship that to production and watch it collapse in a week.
I know because I built the naive version first. Then I rebuilt it. And rebuilt it again. Six months later, I run 53 AI agents on GitHub Copilot that manage my family’s entire life — finances, meals, home maintenance, content publishing, a NICU care coordinator for our premature twins, even a postpartum wellness coach. They run autonomously on 57 cron jobs, coordinate across 75 reusable skills, and communicate through an agent mesh I built for cross-session IPC.
Zero human babysitting. Zero chaos. And the industry is just now catching up.
The Industry Is Catching Up
What’s fascinating is watching the research community arrive at the exact patterns I stumbled into through production pressure.
MegaFlow, a distributed orchestration system from a team of 19 researchers, handles tens of thousands of concurrent agent tasks using a decoupled three-service architecture. Their key insight? Ephemeral task dispatch — spinning up fresh agent instances per task rather than maintaining persistent sessions. I learned the same lesson the hard way after months of debugging polluted context windows. MegaFlow just formalized the math.
HearthNet, out of Imperial College London, built a persistent multi-agent system for smart homes on commodity edge hardware — a Mac mini, an Intel NUC, and an Android phone. Four agents coordinate through MQTT messaging and Git-based conflict resolution, with HMAC-signed leases for authorized device actuation. It’s the closest academic parallel to what I’ve been running: a real home, real agents, real edge compute. You can explore their live demo.
Eric Broda’s The Agentic Mesh on O’Reilly formalizes the agent mesh pattern — ecosystems of agents that communicate asynchronously across service boundaries. I built my own agent mesh using SQLite as the IPC layer before the book existed. Same pattern, different starting point.
The convergence is real. The patterns that survive production aren’t creative — they’re inevitable.
The 4 Patterns That Survived
Out of every architecture I tried, four agent patterns survived six months of daily production use. Not because they were clever, but because everything else broke.
Pattern 1: Domain Agents
Permanent, memory-rich agents that own a specific area of life. My finance-manager owns budgets and bills. My nutrition-chef owns meal planning. Each one has 4-tier memory — core identity, working state, long-term patterns, and an append-only event log. They don’t coordinate with each other directly. They report upward.
Pattern 2: Task Agents
Stateless, single-purpose agents that run a procedure and exit. The daily-briefing agent compiles weather, calendar, tasks, and emails into one morning notification. It has no memory between runs. It doesn’t need any — it reads the current state, formats it, and delivers it.
Pattern 3: Orchestrators
Coordination agents that discover and dispatch other agents. The checkin orchestrator doesn’t know anything about finances or meals. It discovers which domain agents exist, launches them in parallel, collects their reports, and compiles a consolidated notification. Pure delegation.
Pattern 4: Team Agents
Goal-oriented agents with a defined lifecycle. My realtor-team agent coordinates a roster of sub-agents — credit coach, finance manager — toward a specific family goal: buying our first home. Teams are created, run through phases, and eventually complete. Unlike domain agents, they have an exit condition.
The newsletter has the real configs, decision framework, and the code for each pattern. The blog version gives you the overview. The newsletter gives you the implementation.
The Cron Architecture: Why Everything Is Fresh
Here’s the single most important operational lesson from six months of multi-agent production: every scheduled job gets a fresh agent with clean context. No exceptions.
Early on, I reused agent sessions for cron jobs — injecting new instructions into running agents via write_agent. It worked for a week. Then agents started receiving messages meant for other workflows. Context windows filled with irrelevant prior conversations. One agent received a “stay silent” instruction from a previous debug session and went dark for two days.
The fix was brutal and simple: fresh dispatch, every time. My cron scheduler reads a cron.json file with 57 scheduled jobs — heartbeat checks every 2 hours, morning briefings at 6 AM, content pipeline scans hourly, weekly planning sessions on Sundays. Each job launches a brand-new agent instance with clean context. No session reuse. No accumulated garbage.
This is the same “ephemeral task model” that MegaFlow formalized in their research. The pattern is: schedule triggers → launch fresh agent → agent reads current state from memory files → agent acts → agent writes results back → agent exits. Stateless execution, stateful storage.
The Orchestration Layer
The coordination between 53 agents isn’t a monolithic control plane. It’s a set of conventions:
- Agent definitions live in
.github/agents/— each file declares an agent’s identity, domain ownership, and available tools - Skills live in
.github/skills/— reusable procedures that any agent can invoke on-demand - Memory follows the 4-tier system — core identity loaded every run, working state pruned weekly, long-term patterns on-demand
- Communication flows through the agent mesh for cross-session IPC and Telegram for human notifications
- Governance is enforced by three architectural layers — skills for knowledge, extensions for capability, hooks for enforcement
No central brain. No god prompt. No single point of failure. Just conventions that every agent follows because they’re loaded into context on every run.
What’s Next
I’ve written about context engineering as the discipline that makes this possible, about the three layers that prevent agent chaos, and about the home assistant that started this whole journey. This article is the orchestration overview — how 53 agents coordinate without a central brain.
The deep dive — with the real cron.json, agent definitions, orchestrator code, and the fresh-dispatch pattern you can copy — is in the newsletter.
Newsletter Issue #6 includes:
- The 4-pattern decision framework with production configs
- Complete cron architecture — 57 jobs, scheduling rules, dispatch logic
- Fresh-dispatch vs write_agent: the decision flowchart
- Orchestrator discovery and parallel delegation pattern
- Agent mesh IPC setup for cross-session communication
- Real failure stories: context pollution, cron drift, memory bloat
- Lessons from 6 months of daily autonomous operation
This was the overview. The newsletter has the step-by-step implementation. Subscribe at htek.dev/newsletter →
Related reading:
- What Is Context Engineering? A Practical Guide from Building 50 Production AI Agents — The discipline that makes multi-agent orchestration possible
- Why Your AI Agents Keep Forgetting Everything — The 4-tier memory system behind every domain agent
- The Three Layers Your AI Agent Is Missing — Skills, extensions, and hooks: the governance architecture
- Agent Skills: Microsoft Just Shipped What You’ve Been Building — The reusable skills pattern across 75 production skills
- I Open-Sourced the AI That Runs My Household — Where the 53-agent platform started
Need hands-on help building your own multi-agent platform? Book a consulting session — I’ll help you design the architecture, patterns, and cron system for your use case.