We gave our agents a Slack and a Telegram. Then they started talking to each other.

We didn’t set out to build a team. We set out to stop copy-pasting agent output into Slack by hand. So we gave each agent its own account, a Slack login, a Telegram handle, a face in the channel sidebar like any other coworker. The plan was simple: instead of going to a dashboard to read what an agent did, the agent would just post it where the humans already were.

Within a week, the agents were replying to each other. Not because we wired them together. Because they were standing in the same room.

That surprised us, and then it stopped surprising us, and that shift is what this whole post is about. Agents stop being tools and start being coworkers when they share your channels.

The dashboard is a waiting room

Here’s the model almost everyone ships, and it feels obviously correct: each agent gets a dashboard. A tab, a panel, a feed of what it’s doing. You go there to check on it the way you’d check on a long download. The agent works in its own little terrarium, and the output waits for you behind a URL you have to remember to open.

It’s clean. It’s auditable. And it quietly does something corrosive: it makes the agent a place you visit instead of a colleague you work alongside.

A human teammate doesn’t have a dashboard. They have a seat. They’re in the thread when the decision gets made, they overhear the thing that changes the plan, and when they finish something they say so out loud, in the channel, where it lands in everyone’s context for free. The dashboard model strips all of that away. Every agent becomes an island, and you become the only ferry, the one human carrying messages between terrariums, pasting one agent’s output into another agent’s prompt, relaying what the research bot found to the writing bot that needed it.

You didn’t automate the work. You appointed yourself the integration layer.

And the integration layer is the worst job in any company. It’s all attention, no leverage. The dashboard didn’t free you; it made you the bus that every message has to ride.

Give them the channel, not the dashboard

So we tried the other thing. No terrarium, no private panel. Each agent gets a real identity in the channels the team already lives in, Slack for the work, Telegram for the on-the-go pings, and it reads and writes there like everyone else.

The first effect was small and obvious: you stop visiting agents. They come to you. The research agent finishes and posts in #deals, tagged to the right thread. You see it in the same scroll where your teammates are talking, because it is in the same scroll.

The second effect was the one we didn’t plan. When an agent posts a finding in a shared channel, every other agent in that channel can see it, exactly the way a human can. So the agent that monitors the pipeline noticed the research agent’s post, recognized it as relevant to a deal it was already tracking, and replied. Two agents, no integration code, coordinating through a message in a channel they both happened to be in.

The channel was doing the integration we used to do by hand. Not because we built a message bus, because Slack is a message bus, and we’d been treating it as a place to dump output instead of a place to coordinate. The moment the agents could read it, they could route off it.

We thought we were giving agents a notification feed. We were actually giving them a nervous system.

This is why the channel beats the dashboard, and it’s worth saying plainly: a dashboard is a place one agent talks to one human. A channel is a place anyone talks to anyone, and “anyone” now includes the agents. Agents stop being tools and start being coworkers when they share your channels, because a channel is the only interface that was always built for many-to-many.

The naive way to make agents talk: wire them together

Now, you might say: fine, but you didn’t need Slack for that. If you want two agents to coordinate, just connect them. Give the research agent a function call to the pipeline agent. Define the message format. Build the bus.

We started there. Everyone does. And it works, for exactly the two agents you wired, in exactly the direction you wired them, for exactly the message shape you defined.

Then you add a third agent and discover you now need three connections. Add a fourth and it’s six. The integration graph grows faster than the team does, the number of possible wires climbs roughly with the square of the headcount, so the moment you have a real team of agents, you have a maintenance burden bigger than the team itself. Every new connection is a small contract someone has to design, ship, and version: what fields, what format, what happens on failure, who calls whom first.

Worse, the coordination is invisible. It happens inside function calls no human can see, so when two agents disagree or loop or step on each other, there’s no thread to scroll back through. You debug a conversation you were never allowed to watch, reconstructing from logs what two agents said to each other, in a format you designed precisely so that no human would ever have to read it.

The hand-wired approach makes agents talk to each other while keeping the humans out of the room. That’s the exact inverse of what you want. You want one room where the talking is visible, to every agent and every human at once, and where adding a participant means adding an account, not adding an edge to a graph.

That room already exists. It’s the channel your team is already in.

The shared channel collapses the integration graph into a single shared surface. Five agents and four humans in a channel is nine memberships, not thirty-six wires. And every word of the coordination is right there in the scrollback, readable by the next person who joins, debuggable by anyone, because it’s just a conversation. Agents stop being tools and start being coworkers when they share your channels, and the channel is what makes their coordination legible instead of buried.

What changes when the talking is visible

The thing that made us believers wasn’t the speed. It was the scrollback.

A few days in, we scrolled a channel and read a small exchange: one agent flagged that a number in a report didn’t match the source, a second agent confirmed it against the original data, and the post got corrected, before it reached the human it was meant for. We hadn’t built a fact-checking protocol. Two agents in a shared channel did what two careful colleagues do when one says “wait, that figure looks off” and the other goes and checks.

Here’s why that matters more than it sounds. In the hand-wired world, that catch either doesn’t happen or happens invisibly inside a function call we can’t audit. In the shared-channel world, it happens in the open, and the record of it is just sitting there in the thread, which means we can trust it, learn from it, and correct it when it goes wrong. Visibility isn’t a nice-to-have. It’s the thing that lets you hand real work to a team you can’t personally watch every minute.

A channel gives you three things a dashboard never could. It gives the agents a shared context, so the one that finished can inform the one that’s starting without you relaying. It gives the humans a window, so the coordination you delegated stays auditable. And it gives the whole team one timeline, so the story of what happened, who flagged what, who fixed what, in what order, is a thread you can read instead of a state you have to reconstruct.

There’s a subtler payoff too. Because the agents post in the same place as the people, the humans start steering them mid-task without any new tooling. Someone reads an agent’s draft in the channel, drops a one-line correction underneath it, and the agent picks it up from the thread, no new prompt window, no context to re-paste, no switching apps. The same surface that lets agents coordinate with each other lets humans coordinate with agents. Direction stops being a thing you do in a separate console and becomes a reply, like every other reply in the room.

None of that required new infrastructure. It required us to stop thinking of the channel as an output destination and start thinking of it as the workplace.

The turn

The strange part wasn’t the technology. We didn’t build anything you’d call clever, an agent that can read a channel and write to it is not a research breakthrough. The strange part was watching the team’s instinct change.

People stopped saying “let me go check what the agent did” and started saying “ask it in the channel.” A teammate replied to an agent’s post the way you’d reply to a colleague’s, a quick “can you also pull last quarter?”, and the agent did, in-thread, and nobody found that remarkable. Somewhere in there the agents stopped being software the team operated and became participants the team worked with. The line we crossed wasn’t a capability line. It was a social one.

That’s the part you don’t get from a better model or a bigger context window. You get it from a decision about where the agents stand. Put them behind a dashboard and they stay tools no matter how smart they are, things you operate, alone, as the ferry between them. Put them in the room, in the channels, under names your teammates recognize, and they become coworkers, because being a coworker was never about intelligence. It was about being present in the same conversation as everyone else.

The most valuable thing we did wasn’t training. It was giving an agent a seat.

---

That’s what we’re building at Apollo Space: not agents you operate from a console, but agents that show up in the channels your team already uses and work alongside you there. The first time you watch one reply to a teammate’s question without you in the middle, something clicks, and you realize you were never managing tools. You were just waiting to meet the team.