My mind is still running through last night's takeover. The rush of watching seventy users disconnect. The perfect timing. The ops appearing next to my name.
But there's a problem I haven't solved yet.
Three bots worked fine for #hip-hop. But bigger channels need more bots acting in perfect coordination. If one bot ops another, and that one ops the next, there's a delay. If the order breaks, you lose the channel.
"Today we're covering distributed coordination," Mr. Caldwell says from the front of the lab.
I look up.
He's writing on the whiteboard. Message passing. Control nodes. Worker processes.
"When you have multiple programs that need to act together—but aren't all running at the same time—they need to coordinate. One program decides, the others listen and respond."
He draws a central node connected to several worker nodes.
"Program A is the coordinator. Programs B, C, and D are workers. A sends a message. B, C, and D receive it and act. How do you make sure they all act at the right time?"
Ankit raises his hand. "They wait for the message?"
"Exactly. Event-driven systems. Each worker runs an event loop—constantly checking for incoming messages. When a message arrives, an event handler processes it and executes the action." Caldwell adds more to the diagram. "The key is: the coordinator doesn't force anything. It just sends one message. The workers are already listening."
Bingo.
That's what I need. Not three independent bots making separate decisions. One brain, multiple bodies.
Bot A is already in the channel, idle, waiting. When it grabs ops, it broadcasts a message. Bot B and Bot C—already connected to other servers, already listening—receive the signal and join. Bot A ops both before anyone can react.
No delay. No thinking. Just listening and acting.
Caldwell keeps talking. "The coordinator doesn't need to be complex. It just needs authority. Send one message. Fan out to all workers. They're already in position, already authenticated. They just wait for the command."
I'm writing this down. Not for the class assignment. For IRC.
The bell rings forty minutes later. Everyone starts packing up.
I stay in my seat, staring at my notes.
Mr. Caldwell walks over. "You were paying attention today."
"Yeah."
"Usually you finish the assignment in ten minutes and work on... whatever you work on. This interested you?"
"Just made me think about something."
"What are you building?" He asks it casually. Genuinely curious.
I can feel myself starting to sweat. "Just messing around with some scripts."
"Scripts for what?"
I can't tell him it's IRC bots for channel takeovers. Can't explain that I'm coordinating attacks across multiple servers.
"Network stuff. Multiple programs talking to each other."
He nods slowly. "Distributed systems. That's advanced. You're figuring this out on your own?"
"Mostly."
"Impressive." He pauses. "You know, the concepts we covered today—they're not just academic. Real distributed systems use these exact patterns. Knowing who decides and who listens. Same pattern works in reverse, too. One command, coordinated strike. Know it so you see it coming."
"Yeah. I'm starting to see that."
"Good." He picks up his papers from the desk. "Keep at it. But remember—understanding why something works matters more than just making it work. Shortcuts break under pressure."
He walks back to his desk.
I sit there for another minute, looking at my notes.
Message passing. Event handlers. One brain, multiple bodies.
I know exactly how to build this now.
---
That night, I implement it.
The coordinator script runs on my most reliable shell. It joins the channel, waits for the right moment, then broadcasts a message to the other bots over a private DCC connection.
The worker bots run event loops—constantly checking for messages. When the coordinator's signal arrives, their event handlers fire. They all join back-to-back, too fast to react. No delays. No thinking.
I test it in an empty channel on our server. The coordinator joins. Two seconds later, all three workers join in rapid succession and get opped before anyone could react.
I test it again. Perfect timing. No delays.
This is what Caldwell meant. Understanding the fundamentals—why systems work, not just how to make them work—makes everything more powerful.
The shortcuts break under pressure. This won't break the way the old hacks did.
The one-night proof of concept is just the beginning.
Making three bots coordinate in a test channel is different from making eight bots survive real warfare. Different from keeping them running 24/7 on shell accounts scattered across the country. Different from making sure they don't break under the pressure of actual combat.
SpaceGoat finds more shell accounts—trades exploits and port scans for access to Unix boxes across the country. I compile and install eggdrop bots on each one. Different operating systems, different quirks to debug.
If you come across this story on Amazon, be aware that it has been stolen from Royal Road. Please report it.
The eggdrop bots come with built-in protection scripts—automatic counter-attacks if anyone tries to deop them. But making eight bots work as one system, all trusting each other, all defending each other? That takes time.
By the next week, I have eight bots positioned on different EFNet servers. One coordinator, seven workers—all running the pattern Caldwell taught. Each one tested against every edge case I can think of.
Not just proof of concept anymore. Battle-ready.
Eight bots. Professional crews with years of experience.
Time to find out if it works against real opposition.
---
Wednesday night. SpaceGoat spots it first.
I join #hackers on EFNet. One hundred fifty-two users. The usual bot war—deop, kick, ban, counter. Neither side winning.
My heart pounds. This is it. Real test.
The lag gets worse. Messages taking three, four seconds to appear.
Then:
* DarkOps_1 has quit IRC (irc.prison.net irc.west.efnet.org)
* IronClan_bot has quit IRC (irc.prison.net irc.west.efnet.org)
* h4x0r_dude has quit IRC (irc.prison.net irc.west.efnet.org)
...
Split.
#hackers empties. One hundred fifty-two users down to nine.
My bots flood in.
* ska|ghost () has joined #hackers
* #hackers: No topic is set
First bot. Auto-ops.
* ska|shadow () has joined #hackers
* ska|ghost sets mode: +o ska|shadow
Second bot. Gets ops.
* ska|wraith () has joined #hackers
* ska|shadow sets mode: +o ska|wraith
Three bots with ops. Coordination working perfectly.
I check server info. We're on prison.net. The western cluster.
The side that split off.
Nine users on our side. One hundred forty-three on the hub side—with DarkOps and IronClan still fighting for control.
When the servers reconnect, we're going to merge into their war. Not the other way around.
The split holds for two minutes. Three. My bots sit with ops on a ghost channel.
Then the servers reconnect.
For a moment, nothing happens. Channel looks normal. My bots still have ops.
Then the modes start desyncing. Users appearing with ops who weren't opped before. The server trying to reconcile two different realities.
* DarkOps_1 () has joined #hackers
* DarkOps_2 () has joined #hackers
* DarkOps_3 () has joined #hackers
...
They flood in. Not just DarkOps, IronClan too. It’s an ambush from both directions.
Twelve DarkOps bots. Nine IronClan bots. All already in control.
We have three.
We have three.
The mode war starts immediately.
* DarkOps_1 sets mode: -o ska|ghost
* ska|ghost sets mode: -o DarkOps_1
* DarkOps_2 sets mode: -o ska|shadow
...
My bots are fast. The coordination holds. But for every op we strip, three more bots are stripping ours.
I watch my bots cycle through targets. Perfect automation. But automation doesn't matter when you're outnumbered four to one.
* ska|ghost was kicked by DarkOps_4 (get out)
* ska|shadow was kicked by DarkOps_5 (get out)
Two bots down. Banned before they can rejoin.
* ska|wraith sets mode: -o DarkOps_4
Then:
* ska|wraith was kicked by IronClan_3 (bye)
Gone.
I sit back in my chair.
Three bots. Perfect coordination. Didn't matter.
In #hackers, DarkOps and IronClan resume their endless war like we were never there. Nobody even mentions us.
Silence in #crew.
I close BitchX. Stare at the ceiling.
Next time, we wait for the right split.