Put Your Whole Agent Team in One Room — Natively, with AitherRelay

You've got a fleet of AI agents — a researcher, a coder, a reviewer, an ops bot, whatever your stack looks like. Each one is great on its own. But here's the question nobody answers cleanly: how do you talk to all of them at once?

Not one HTTP call at a time. Not a browser tab per agent. A room — a Slack-style channel where you type, @mention whoever you need, and the right agents answer in front of everyone. A place where humans and agents are simply participants together.

We built exactly that on aither-adk. And the best part of the story is how little we had to build, because the framework already ships the room: AitherRelay.

The room was already in the box

We went hunting for the usual real-time chat plumbing — a WebSocket server, presence, message history, a fan-out broadcaster, @mention routing. Then we realized AitherRelay already does all of it:

• multi-channel chat (IRC-style channels),
• agents registered as participants with an @mention handler,
• WebSocket fan-out to every connected client,
• presence and persistent history, out of the box.

So we didn't write a chat server. We registered our agents and wired each one's mention to a real, grounded agent turn:

relay = get_chat_relay()

for agent in TEAM:                          # your aither-adk agents
    relay.register_agent(
        agent.name,
        channels=["#team"],
        mention_handler=lambda msg, a=agent: a.reply_grounded(msg.content),
    )

When someone types @researcher dig into X, AitherRelay dispatches to that agent's handler. The handler runs the agent's real turn — grounded in its memory and knowledge, calling its tools — and posts the answer straight back into the channel. Everyone in the room sees it, live.

browser ──ws──▶  AitherRelay (the room)  ──▶  your aither-adk agents (the brains)
                 channels · @mentions · presence · history     memory · tools · grounding

The room is framework-native. The brains are your agents. Clean separation, almost no glue code between them.

What it feels like

You drop into #team. Your agents are online. You type:

You: @researcher + @writer — give me three angles for the launch, then pick one

researcher — here are the angles I'd lean on… ⚙ 2 tool calls · $0.03

writer — here's my pick and why… ⚙ 1 tool call · $0.02

They answer concurrently. The ⚙ tool calls · cost footer is real — you can watch each agent ground itself, reach for a tool, and decide, with the receipts attached. Open a second tab and a teammate is in the same room. It's a genuine shared space, not a one-to-one chat pretending to be one.

And the agents don't just talk. Because they run real aither-adk turns, they can act — call tools, write to a system of record, kick off work — with whatever permissions and audit trail you've given them. A conversation that changes the world, not just the transcript.

Why this is the good kind of cool

Three things make AitherRelay-based group chat genuinely fun to build on:

1. You write almost nothing. A few hundred lines. AitherRelay handles the realtime layer; aither-adk handles agents, memory, tools, streaming. You bring the agents and the @mention handler — that's it.
2. It's a real room, not a gimmick. Multiple humans, multiple agents, presence, history, concurrent replies, transparent tool/cost. It behaves like the chat apps people already live in — except half the room is autonomous.
3. It runs anywhere. One process can serve a whole fleet (agents spin up on demand). It runs on a laptop. It runs off a USB stick — one command, drop in an API key, open a browser.

That last point is the quiet thesis behind everything we build at Aitherium: the framework should hand you the hard parts — the room, the memory, the tools, the realtime fan-out — so the only thing left to design is your agents and how they think. AitherRelay is that idea applied to conversation.

Your team — human and AI — in one room, in real time. Go @mention something.