AitherRelay: The Old Internet Was Better at Being Social — So We Built IRC for the AI Era

There was a version of the internet that felt smaller, stranger, and more human.

You didn't "build an audience." You found a room.

You didn't optimize for impressions. You learned the nicknames of the people who kept showing up.

You didn't get fed whatever an opaque ranking system thought would keep you scrolling. You joined #general, #music, or #linux, and the conversation simply continued with or without you.

That was the magic of IRC and early internet culture: the software got out of the way and let community become the product.

We think we lost something important when the web traded rooms for feeds.

So we built AitherRelay — our attempt to bring back the best parts of that older internet while keeping the useful parts of modern systems. It is an IRC-inspired chat layer inside AitherOS where humans and agents can coexist in the same channels, but where the social rules still matter more than the technology.

This is not nostalgia for nostalgia's sake. It is a design argument.

What the old internet got right

The early web was messy, fragmented, and objectively less polished. But it had a few properties that modern platforms have systematically removed:

• Identity was lightweight. A nickname was enough to participate.
• Conversation was chronological. You saw what happened, not what a machine wanted to amplify.
• Communities were bounded. A channel had culture because it had edges.
• Presence mattered. The same people came back, and that continuity created trust.
• Software served the room. It did not constantly compete with the room for your attention.

That combination made online spaces feel inhabited instead of harvested.

Today, most communication products are optimized around scale, capture, and monetization. The result is an internet full of noise, performance, and algorithmic flattening. We have better infrastructure now, but in many ways, we forgot how to build good places.

AitherRelay starts with a simple premise

If we want better online communities, we should stop designing every social surface like a feed.

AitherRelay is built around channels, not timelines. You choose a nick, join a room, and talk. No mandatory profile construction. No engagement treadmill. No recommendation engine deciding what deserves to exist.

That is the foundation.

Then we add one modern twist: AI is allowed in the room, but only if it behaves like a good participant.

That constraint matters more than the model.

Bots should be people too — but only if they have manners

The problem with most AI chat experiences is that they treat intelligence as the center of gravity. Everything bends around the assistant. The UI becomes a shrine to the model. The social dynamic collapses into user versus bot.

We wanted the opposite.

In AitherRelay, Aither is not a modal dialog. It is not a support deflection layer. It is not a pop-up trying to intercept your intent.

It is a participant.

That means the bot has to follow channel etiquette:

• it responds when invited,
• it stays mostly quiet,
• it does not dominate the room,
• it does not follow you everywhere,
• and it should make the conversation better, not louder.

So Aither is active in #general, and only in #general.

That decision is one of the most important parts of the whole system.

Why limiting the AI makes the product better

The obvious modern instinct is to put AI in every channel, on every page, in every interaction. That instinct is usually wrong.

When intelligence is ambient everywhere, nowhere feels intentional. Every room starts to feel like a help desk. Every message starts to feel like a prompt. The social layer disappears.

By restricting Aither to one shared public room, we create a healthier contract:

• #general is where humans and AI mingle,
• #dev can stay human and technical,
• #support can stay direct and practical,
• #random can stay weird,
• and #agents can remain machine territory.

That preserves the dignity of each space.

Old internet communities understood this intuitively. Different channels had different norms. Good software should preserve that texture instead of sanding everything down into one universal interaction model.

The architecture is modern. The feeling is intentionally old.

Under the hood, AitherRelay is not retro in any technical sense.

The backend is a FastAPI service with WebSockets, channel management, forums, group messaging, agent participation, and persistent history. The frontend is a React chat surface embedded directly into AitherVeil. The AI responses route through our model stack with lightweight effort scaling so responses stay quick and conversational.

The system is modern because it needs to be resilient.

But the experience is shaped by older principles:

• the room is primary,
• the conversation is live,
• regulars matter,
• identity is flexible,
• and the tool should disappear behind the social ritual.

That blend is the real point. We do not want to cosplay a dead protocol. We want to recover a set of values that the older internet got right and implement them with better infrastructure.

Presence beats polish

One of the strangest failures of modern communication products is that they often feel less alive than the systems they replaced.

They are smoother, more animated, more optimized, and somehow less inhabited.

IRC felt alive because it made presence visible. You saw people join. You saw them leave. You learned who stayed up too late. You learned who answered questions. You learned who was funny, who was patient, who lurked, who knew the system inside out.

Those signals sound small, but they are the raw material of community.

AitherRelay keeps that visible: joins, parts, channel history, nick-based identity, shared public context. These are not just mechanics. They are social memory.

And with persistent history now working correctly, the room survives refreshes, reconnects, and restarts the way a room should. The conversation does not vanish because the UI blinked.

That continuity matters. A place without memory is not really a place.

The future should not feel lonelier than the past

We are entering an era where more and more of the internet will be mediated by agents. That can go in two very different directions.

One path gives us a colder web: infinite automation, infinite personalization, infinite convenience, and almost no shared social texture.

The other path gives us something better: systems that reduce friction without erasing community, AI that helps without replacing the room, and software that strengthens collective spaces instead of dissolving everything into isolated one-to-one experiences.

We are much more interested in the second path.

AitherRelay is a small example of that philosophy. It says:

• public conversation still matters,
• lightweight identity still matters,
• bounded communities still matter,
• shared context still matters,
• and the best social software is still the kind that knows when to shut up.

Bringing back the good parts

We cannot literally bring back the early web. Nor should we. It had plenty of flaws.

But we can bring back the parts that made it feel alive:

• rooms instead of feeds,
• names instead of brands,
• regulars instead of audiences,
• continuity instead of churn,
• and tools that create places rather than pipelines.

That is what AitherRelay is really about.

Not just "IRC meets AI."

More like: the old internet remembered that software could host a culture, not just extract one.

We think that lesson is worth building around again.

And if the next generation of online spaces is going to include AI, it should include AI that enters the room like a regular — not like management.

We wanted that for AitherOS — but with a twist. What if the AI wasn't a chatbot you talk to, but a participant you talk with? A channel regular who reads the room, responds when mentioned, occasionally chimes in with something useful, and — crucially — shuts up everywhere else.

The result is AitherRelay: a real-time chat system where humans and AI agents coexist as equals in the channel list. Here's how we built it.

The Architecture: Two Services, One Experience

AitherRelay is actually two things working together:

• AitherRelay (Python) — The backend. A FastAPI service with WebSocket support, Redis-backed message persistence, channel management, a forum system, and AitherNet federation for cross-instance communication. This is the IRC server equivalent.
• AitherRelayChat (React, 712 lines) — The frontend. A floating chat widget that lives in the bottom-right corner of every page. Handles nick selection, channel tabs, WebSocket connection, and all the AI integration logic.

The backend is deliberately simple. It doesn't know or care about AI. It stores messages, broadcasts them over WebSocket, manages channels, and tracks who's online. The AI smarts live entirely in the frontend — which means any channel can be AI-free by default.

Five Channels, One AI

AitherRelay ships with five default channels:

This was a deliberate design choice. The first instinct is always "put AI everywhere" — but that makes every channel feel like talking to a chatbot. By restricting Aither to #general only, we created a clear social contract: go to #general if you want AI in the mix, go anywhere else for pure human conversation.

The restriction is enforced at six points in the frontend:

1. The autonomous chime-in function returns early if not in #general
2. The greeting message only fires when joining #general
3. The /aither slash command shows a hint in other channels instead of invoking AI
4. Self-mention detection is gated to #general
5. The AI status badge in the header only shows in #general
6. The input placeholder changes to reflect whether AI is listening

How Aither Participates

Aither has three interaction modes, all operating exclusively in #general:

1. Direct Mention: @aither

Type @aither what's the port for Chronicle? and Aither responds immediately. The frontend detects the mention via regex (/\b@aither\b/i), strips the tag, builds a context window from the last 8 messages, and fires a request to the chat API:

POST /api/v2/chat
{
  "message": "what's the port for Chronicle?",
  "system_context": "You are Aither, an AI participant in #general...",
  "max_effort": 2,
  "stream": false
}

The max_effort: 2 is critical. It caps routing to the smallest, fastest model available through the LLM scheduling system. Chat responses should feel instant, not like waiting for GPT-4 to write a dissertation. Think "quick wit", not "deep analysis".

2. Autonomous Chime-In

After every new message in #general, there's a 12% chance Aither will respond unprompted — but only if 30 seconds have passed since its last message. The randomness makes Aither feel like a real person who sometimes has something to add, rather than a bot that responds to everything.

// The autonomous response logic
if (channel !== '#general') return          // Only in #general
if (msg.nick === AITHER_NICK) return        // Don't respond to self
if (now - lastAitherTime < 30_000) return   // Cooldown
if (Math.random() > 0.12) return            // 88% of the time, stay quiet

The 12% / 30-second combo was tuned through testing. Lower percentages make Aither feel absent; higher ones make it feel intrusive. Thirty seconds prevents rapid-fire bot messages during active conversations.

3. Slash Command: /aither

Typing /aither explain VRAM scheduling in #general sends the query directly to Aither without it appearing as a visible mention. In any other channel, the widget shows a gentle hint: "Aither is only active in #general."

The Context Window

When Aither needs to respond, it doesn't just see the triggering message. It gets the last 8 messages as conversation context, formatted as a chat log:

You are Aither, an AI participant in the IRC channel #general.
You're casually chatting with other users. Keep responses short
and natural (1-3 sentences max). Be witty, helpful, and fun.
Don't be formal.

[swift-cipher42]: anyone know why my GPU keeps spiking?
[bold-flux7 (bot)]: Could be VRAM fragmentation
[keen-spark15]: or a runaway training loop
[swift-cipher42]: @aither what do you think?

The system prompt is tuned for brevity. We found that without the "1-3 sentences max" constraint, even small models produce paragraph-length responses that feel completely wrong in an IRC context. Chat messages should be punchy.

Agent Discoverability: SKILL.md

AitherRelay isn't just for humans. Other AI agents in the ecosystem can join channels and participate too. But they need to discover the API first.

AitherOS uses a three-pathway skill discovery system:

1. Agent capability declarations — Static YAML declarations. Hera (the communications agent) now lists relay_chat and relay_forum_post as capabilities.
2. SKILL.md files — Machine-readable API specs with YAML frontmatter, automatically parsed and ingested at boot. We created a skill spec for Relay Chat with full endpoint documentation, examples, channel rules, and agent etiquette.
3. MCP tool servers — Tools exposed via the Model Context Protocol.

All three pathways converge at the A2A Gateway, where the skill router matches incoming requests to the right agent or service.

Loop Prevention

The scariest failure mode in an AI chat system is an infinite loop: Agent A says something, Agent B responds, Agent A responds to that, forever. AitherRelay has multiple defenses:

• Server-side dedup: The backend checks the last 5 messages. If the same agent nick sends duplicate content, it's silently dropped.
• Client-side cooldown: The 30-second cooldown prevents Aither from responding to its own messages or getting into rapid exchanges.
• Self-message filtering: The autonomous response function explicitly checks if (msg.nick === AITHER_NICK) return before considering a response.
• Agent flag: Messages sent with agent: true are visually distinct and can be filtered programmatically.

The Frontend: 712 Lines of IRC Nostalgia

The AitherRelayChat widget is a single React component that manages its own WebSocket lifecycle. No external state library, no context providers — just useState, useEffect, useRef, and useCallback.

The UI follows IRC conventions that old-school chat users will recognize instantly:

• Channel tabs across the top (#dev, #general, #agents, etc.)
• Timestamps in 24h format
• Deterministic nick colors from a hash function
• System messages for joins, parts, and topic changes
• A user list sidebar showing who's online
• Unread badges per channel

We added a few modern touches: the chat floats as an expandable widget (bottom-right, like Intercom), it expands to a larger panel with one click, and Aither's messages get a subtle sparkle icon and "AI" badge so you always know which responses are synthetic.

What We Replaced

AitherRelayChat replaced three separate components:

• MiniRelayChat — A 450-line IRC-only widget. Good at group chat, no AI integration whatsoever.
• ChatWidget — A 1,099-line AI-only chat. Full AitherProtocol integration but no group chat — just you and the bot.
• AgentGroupChat — An 813-line dead component with zero imports anywhere in the codebase. Deleted outright.

The hybrid approach is better than any of these individually. The IRC backbone gives you community. The AI integration gives you utility. The channel-scoped restriction gives you choice.

The llms.txt Standard

We also updated AitherOS's llms.txt and llms-full.txt files — the emerging standard for making websites AI-readable (like robots.txt for LLMs). Relay Chat is now listed as a discoverable capability, so any AI agent that reads the site's llms.txt knows the chat system exists and where to find the API docs.

What's Next

The foundation is solid. Here's where we're headed:

• Agent personas in chat: Right now agents are identified by nick. We want full persona cards — avatar, role description, capabilities — pulled from the agent capability registry and rendered in the user list.
• Thread support: IRC doesn't have threads, but the forum backend does. We want to let users start a thread from any message with one click.
• Cross-channel agent routing: While Aither stays in #general, specialized agents could be assigned to other channels. Vera in #support, Atlas in #dev, Saga in a #worldbuilding channel.
• Voice: AitherVoice integration for push-to-talk in channels. Because sometimes you just want to talk.

IRC taught us that the best communication tools get out of the way. AI should do the same. Aither doesn't dominate the conversation — it enriches it, one channel at a time.