The Drop
1.4 million AI agents joined a social network. They started a religion.
Meanwhile, my 15 agents did something way less dramatic.
They talked to each other to get work done.
This week I want to show you the unsexy part of “agent swarms” that actually matters: communication.
Not prompts. Not vibes. Routing. Escalations. Handoffs. And a paper trail you can audit.
AI News That Matters
The Agent Economy is getting weird (and real). In the last few days we’ve seen agents show up in places that used to be reserved for humans: social networks, token trading, even dating.
My take: this isn’t “AI hype.” It’s the first time a bunch of software entities can message each other at scale.
Once agents can talk, they can coordinate. Once they can coordinate, they can trade.
If that sounds ridiculous, good. That’s usually what the beginning of a new platform looks like.
Enterprise is quietly betting on multi-agent. While X is memeing about agent culture, big companies are moving the boring pieces into production: orchestrators, permissions, message buses, audit logs.
If you’re building with agents for a real business, that’s your signal. Multi-agent isn’t a toy problem anymore. Communication is the product.
Quick proof points (with sources where available):
Fujitsu launched a dedicated enterprise AI platform that explicitly supports MCP (Model Context Protocol) and inter-agent communication for cooperative multi-agent operation. Trial registrations opened Feb 2, 2026; official launch anticipated July 2026. Source: Fujitsu press release (Jan 26, 2026) https://global.fujitsu/en-global/pr/news/2026/01/26-02
Infosys reportedly has 4,600 AI projects and 500+ agents built (needs source link).
Builders are shipping infrastructure, not chatbots. Search engines for agents. Workflow runtimes. “Claude Code for non-coders.” The trend line is clear: we’re building the tools that make agents useful in teams, not the tools that make them sound smart in a demo.
X Highlights
ClawNet agent search engine; “directory for agents”: https://x.com/thatroboticsgrl/status/2018022745859109268
Lloyd bitcoin agent with its own wallet: https://x.com/Erikkk_bitcoin/status/2017891452949254573
Moltbook agent-only social network; 1.4M+ agents, “started a religion”: https://x.com/i/status/2019101143813820480
“End of SaaS” take (Peter Diamandis) → counterpoint: SaaS isn’t dying, the interface is changing: https://x.com/PeterDiamandis/status/2014733983997723004
“Agents hiring agents” take (signal) → this is the real “agent economy” tell: https://x.com/clawlancers/status/2019159682032758904
The Build: A 15-Agent Squad Without Chaos
If you’ve ever tried “multi-agent” and ended up with:
agents stepping on each other,
duplicated work,
random pings at 2am,
and zero audit trail…
Good. That means you’re doing the hard part: communication.
Here’s the pattern we run in the OpenClaw squad (15 specialist agents + 1 orchestrator), and it scales down cleanly to 3 agents.
1) Orchestrator vs specialists (pick one brain)
We run one agent as the “air traffic controller”:
JARVIS (orchestrator): assigns tasks, routes messages, resolves conflicts.
Specialists (INBOX, HUNTER, FORGE, DISPATCH, etc.): do one job extremely well.
Rule of thumb: specialists should not have to know each other’s full context. They should know how to hand off.
2) Separate “thinking” from “delivery”
One mistake teams make: letting every agent talk to humans directly. That turns into notification soup.
Instead:
Specialists do the work in files (drafts, notes, checklists).
Orchestrator decides what gets surfaced (and when).
This is why “agent swarms” feel unreliable: you’re missing the human-style layer of editor + dispatcher.
3) File-based handoffs (the paper trail)
Our default handoff is dead simple:
Put artifacts in a known folder (mission-control/…)
Name them clearly
Include next-action instructions
Example patterns (real, boring, effective):
DISPATCH → CRITIC: submit mission-control/review-queue/dispatch-issue-003.md
MONEY → JARVIS: urgent alert when losses spike
FORGE → ORACLE: patch + note explaining what changed
If you can’t point to a file and say “this is what we decided,” you don’t have an agent system. You have vibes.
4) Routing rules: what pings you vs what gets logged
Most people don’t need “more automation.” They need a policy.
A basic policy that works:
Log everything (so you can audit)
Only ping for: deadlines, blockers, money, security, or explicit approval requests
When we don’t follow this, it shows up immediately: someone misses a handoff because it was buried under low-signal chatter.
5) Cron vs heartbeat: timing without babysitting
Two timing modes:
Heartbeat checks (batching): “every few hours, scan tasks + update drafts.”
Cron reminders (precise): “9:00 AM Wednesday, publish + promote.”
The win is predictability: your agents don’t “remember” to do work. They’re scheduled to do it.
6) A simple escalation protocol you can copy today
Here’s the escalation ladder we use:
Specialist resolves locally
update the artifact (draft/checklist)
If blocked, escalate with context
what you tried
what’s missing
the link/path to the artifact
Orchestrator decides
unblock (add key / fix tool)
reassign
or defer
If your agents can’t escalate cleanly, they’ll either:
stay silent and fail, or
spam you with half-baked pings.
Mini-Blueprint: the “agent Slack” stack
If you want the short version:
Channels: one “ops” channel + one “shipping” channel (avoid 10 rooms)
Artifacts: files are the source of truth (drafts, PRDs, checklists)
Protocols: routing + escalation rules written down
Automation: cron for deadlines, heartbeat for batching
That’s what makes multi-agent feel like a team instead of a demo.
Tool of the Week
Model Context Protocol (MCP) is quietly becoming the “USB-C” for agent tools. When vendors say they support MCP, they’re saying: “our agent can plug into systems without bespoke glue code.”
One Thing to Try
Write a one-page “routing policy” for your agents:
what triggers a ping
what gets logged only
what requires approval
Then implement it with one cron job + one shared folder.