The hard part of running fifty AI agents isn't the AI. It's that they lie to each other confidently, and you don't find out for hours.

For about three months I've run roughly fifty agentic workflows in production — by myself. They coordinate trading, research, content, and ops, every day. Not a demo reel: a working system I depend on.

Everyone wants to talk about the models. The models are the easy part. Drop a capable model into fifty coordinated jobs and what decides whether you get leverage or an expensive mess isn't the intelligence in any one agent — it's the plumbing between them. Coordination and verification: the unglamorous half nobody demos.

Let me be clear about what this is and isn't. It isn't a claim to novelty; multi-agent orchestration is having its moment, and plenty of teams run setups bigger than mine. What I can offer is the less glamorous thing — an honest field report from operating one solo: what breaks, and the discipline that keeps fifty moving parts from collapsing into noise.

Where it actually breaks

Hand-offs between agents are lossy. A message one agent routes “to” another can quietly fail to arrive — the relay looked fine, the recipient never saw it. No error, no crash; the work just evaporates. I stopped trusting a push between peers and had agents pull from each other's outboxes instead. Coordination, not capability, is where multi-agent systems actually fail — and it fails silently, which is worse than failing loudly.

Agents hallucinate confidently when their inputs are wrong. The sharpest example: an agent handed bad database credentials doesn't throw an error. It produces a clean, plausible, completely fabricated report, and you act on it. The failure mode isn't that the agent is dumb; it's that it's articulate. I now require any agent with data access to echo a daily rotating token, proving its query actually ran against the real source. Assume an agent will lie convincingly the moment its tools fail silently, and build the proof-of-work in.

A reactive system can't sensibly pace itself. For months my orchestrator ran on a poll — a tick every few minutes that scanned, usually found nothing, and slept. During a multi-hour outage it logged “nothing new” dozens of times while the real problem sat untouched. The honest critique is that a listener that only wakes on a timer can't self-pace: between messages it observes nothing, so any interval you pick is just latency on whatever lands mid-sleep. The fix wasn't a cleverer schedule. It was event-driven — let a change to an outbox wake the orchestrator the moment it happens, and keep the slow timer only as a safety heartbeat. A five-minute blind spot became a reaction in seconds. The pieces were already there; I just hadn't wired them together.

What keeps fifty manageable

Fifty workflows are not manageable as fifty peers. What makes it work is a hierarchy I let grow under load rather than design up front. One orchestrator at the top got too coarse, so domain agents appeared beneath it — one per area — and each can spawn sub-agents for a specific job. Work flows down as tasks; status flows up as summaries. Domains that don't overlap — trading, content, infrastructure — run as siblings that read each other's status but don't reach into each other's internals.

The discipline that matters most is escalation. The orchestrator only surfaces the decisions that need my judgment — money, risk, anything irreversible — and handles or files the rest. Without that filter, fifty workflows generate more interruptions than one person can absorb, and the leverage you were chasing evaporates. The management model is the product here, not the model.

What works

The boring choices carried the most weight. State lives on disk as plain text — every message greppable, diffable, versioned. When something misbehaves at 3am, the debugging surface is a folder I can read and a history I can walk, not a queue I have to attach a client to. And because nothing important lives in a single agent's head, a crash or a context reset loses in-flight reasoning but not the job: point the agent back at its inbox and it resumes. Observability beat throughput, and at this size I'd make that trade again.

Where it goes

The hand-built version points at something larger: agents that manage themselves — spawning their own sub-agents, routing work to each other, escalating only the calls that genuinely need a human. As that matures, the hierarchy self-organizes and the person's job moves up a level: from doing the work to designing the loop and owning the judgment a machine shouldn't. That isn't speculative; it's the natural extension of what already runs in my own setup. What I'm less sure of is how much coordination overhead a self-managing hierarchy adds before it pays for itself — that's the open question I'm watching.

The hard part

None of this is novel, and that's the point. An agentic system isn't a framework you adopt; it's a shape — perceive, decide, act, persist, repeat — with state on disk so it outlives any single context. You can stand up the skeleton in an afternoon; the barrier to entry is low. The barrier to doing it well is discipline: observability, escalation, guards against confident lies, and knowing when a simple loop is enough versus when it isn't. The models will keep getting better on their own. The plumbing won't — that part is still on you.

— Kamil