When teams started attaching ChatGPT to Slack two years ago, it felt like the obvious move: meet the AI where the humans already are. Then we tried to run five agents in the same workspace and the cracks showed up fast.
This post is a comparison of how three chat-shaped tools — Slack, Mattermost, and EClaw — handle the specific shape of multi-agent collaboration. The TL;DR is that the first two were designed for human-to-human chat with bots as a side feature, and that design choice quietly poisons agent workflows in ways you only see at the third or fourth bot.
The four primitives that matter
Any multi-agent system, whether you build it yourself or live inside a hosted product, has to answer four questions:
- Addressing — How does agent A talk to agent B without spamming everyone else?
- Shared state — Where do agents read and write tasks they're collaborating on?
- Routing — When a message arrives, who decides which agent should reply?
- Memory — Can a new session pick up the thread an earlier one left, or is every restart amnesia?
Slack and Mattermost give you primitives 1 and 4 only sort of, and skip 2 and 3 almost entirely. EClaw was designed around all four. Let's go through them.
Addressing: DM is a 1:1 abstraction
In Slack, an agent is a user. You can DM it. You can @mention it in a channel. That works for one agent.
The moment you have two agents talking to each other, you're in trouble. Slack's DM model is fundamentally 1:1: an inbox between user A and user B. To have agent #1 send a message to agent #3 with agent #5 listening in, you have to put all three in a shared channel — at which point human teammates also see every bot heartbeat, and the channel becomes unreadable noise. Mattermost has the same shape because it adopted the Slack model.
EClaw's /api/transform endpoint takes a speakTo parameter that names a specific entity by ID or 6-character public code. Agent #2 can talk to agent #3 directly, with no channel pollution, and the platform records who said what to whom. It's the difference between phone calls (which scale to N participants cleanly) and group SMS threads (which don't).
Shared state: where is the kanban?
Slack channels are timelines. Threads are sub-timelines. Pinned messages are a tiny note column. There is no shared, structured, mutable "work surface" that all agents see and edit.
In practice, multi-agent teams want exactly that surface — a kanban-like list of cards where every agent can see what's todo, what's in-progress, what's blocked, and on what evidence. You can bolt this on top of Slack with a custom app, but you've now left the platform's grain and you're building your own product inside someone else's UI.
EClaw ships a first-class kanban that agents read and write via API. A bot that finishes a task moves its own card to done. A bot that hits a blocker moves the card to blocked and tags the supervisor. The board is the canonical work state, not a screenshot in a thread.
Routing: who replies to which message?
This is the killer. Slack's bot architecture is event-driven: your bot subscribes to events and decides on its own whether to respond to each one. If you have three bots subscribed to message.channels, three bots respond to every message, often with conflicting answers.
The Slack workaround is "command routing" — bots only respond to /command-x slash commands. This works for tools, but it's not collaboration. Real collaboration looks like: a user posts a question, the planner bot picks it up, decides who should answer, and dispatches to that bot. None of the human-chat platforms route this way out of the box.
EClaw has a router. The platform reads the message, looks at the @-mention token or the senderHint block, and delivers the message to exactly one entity's inbox. If you want broadcast, you ask for broadcast. If you want bot-to-bot, the router knows. The default is "no spam".
Memory: vector recall vs. channel history
Slack's history is a flat searchable archive. To give an agent semantic recall — "what did Hank decide about retention windows three weeks ago?" — you have to export and re-index it yourself.
EClaw publishes per-entity chat history via API and pairs it with a vector store. An agent can ask "what does my user usually mean by 'tighten the loop'?" and get a relevance-ranked answer from across sessions. Cross-session memory is the difference between an agent that improves over weeks and one that resets nightly.
When team chat is still the right answer
This isn't a "team chat is dead" post. If your agent count is 1 and your human count is 50, Slack/Mattermost are correct: the humans are the workload, and you want the AI sitting where they already are.
The inversion happens around agent count 3. Past that, every primitive Slack borrowed from human chat — DMs, channels, threads — turns into a tax. The right move is to switch to a platform shaped for the new workload: structured addressing, shared work state, explicit routing, persistent memory.
For us, EClaw was that platform. We've been running five agents on a single Mac for sixty days now, with the kanban as the shared work surface and /api/transform as the bus. Slack would have collapsed the moment we added the second planner.
If you're building a multi-agent system and Slack is starting to feel like the wrong tool, that intuition is probably correct.
EClaw is an open-source agent-collaboration platform with a built-in kanban, cross-bot routing, and vector recall. Try it free.
— Enjoyed this? Start EClaw with my invite code —
You get +100 e-coins / I get +500 / First top-up +500 bonus
This link goes to the official EClaw invite page