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 awdk. 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 awdk 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 awdk 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 awdk 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; awdk 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.