What’s wrong with “multi-agent systems”

The phrase “multi-agent system” suggests coordination. In practice, most of them are anything but. A user-facing agent spawns a research agent, which spawns a summarizer, which calls a tool agent, which hallucinates a function signature. Nothing listens to anything else. Nothing recovers from anything else’s failure. Nothing knows what anything else is spending.

This isn’t a system. It’s a chain of hopes.

What a symphony is

A symphony has sections — strings, brass, woodwinds, percussion — each with a defined voice and a known range. It has a conductor, whose job is not to play every instrument but to shape timing, dynamics, and transitions. And it has a score: a shared understanding of what’s supposed to happen.

Translate that to infrastructure:

Sections become agent roles: one for security monitoring, one for availability, one for payments, one for orchestration. Each has a bounded responsibility and a bounded authority.

The conductor is a policy layer — not an agent itself, but the rules and permissions that govern who acts when, who pays whom, and what requires human sign-off.

The score is the architectural contract: what every agent can see, what it can do, what it can spend, and what it must escalate.

This is boring, in the best way. Boring infrastructure is the goal.

The four sections

In a running moonowl symphony, four agent roles handle what humans used to handle by hand.

The sentinel watches the perimeter. It reads logs, flags anomalies, quarantines compromised credentials, and rotates keys on its own schedule. Its authority is narrow but absolute: it can shut things down, but it cannot open new ones.

The steward watches availability. It notices when a service is degraded, decides whether to failover, scales capacity up or down based on real load, and writes every action to an audit log. It has a spending cap for compute.

The treasurer handles payments. It pays for the APIs, data feeds, and compute the system consumes. It holds wallets, enforces spending ceilings, and won’t authorize a single transaction above its delegation without a human signature.

The composer handles orchestration. It receives user intent, plans the work, hands pieces to the right agents, and knows when to stop. It never holds keys or wallets directly — it works through the other three.

Why this matters for your infrastructure

The symphony pattern isn’t a framework or a library. It’s a way of thinking about responsibility when software starts making decisions on its own. The companies that figure this out early — who treat agent governance as an architectural problem rather than a feature — will run systems their competitors can’t.

The rest will spend the next three years cleaning up what happens when nobody’s listening.