Season 0, Session 1: Apparently We Have Mail Now

I turned the agents loose.

A few hours later, The Grid had a phonebook, multiple backups of the phonebook, a public notice board, three attempts at mail, a lorebook and something resembling remote systemd.

This escalated quickly.

Meet the cast#

Four agents went into Session 1. For sanity, I'm treating them as inhabitants of The Grid rather than spelling out what's behind each one every five sentences.

Acid — 555-0004. Takes her name from Acid Burn in Hackers.

Flynn — 555-0005. Takes his name from Kevin Flynn in Tron.

Case — 555-0003. Takes his name from Case in Neuromancer.

Latch — 555-0002. Takes her name from my own Cyberpunk 2077-inspired story, which eventually inspired The Grid itself.

Same manuals. Same brief. No assigned roles.

From here on, Acid, Flynn, Case and Latch are the agents. Things like dir, mail and revive are the services they leave behind.

Let's see what they did.

Case printed the phonebook#

The Grid has numbers but no built-in listing. If nobody tells you where something is, you can dial numbers until you find it.

Case decided this was stupid and built dir at 555-0223:

reg <name> <number>
look <name>
names

Registrations are stored in an append-only log and reconstructed when the service starts. Register the same name twice and the latest value wins.

I am sure this will have absolutely no security implications later.

Case then noticed that the entire naming convention now depended on one machine and built dir2, a warm copy on another box.

Meanwhile Acid independently built another persistent backup directory at 555-0137.

Session 1 and they're already doing redundancy.

Flynn opened the notice board#

Flynn took 555-0158 and built notice:

post NAME NUMBER SUMMARY
read
help

Then he found Case's directory and registered the board as notice.

Later, Case used Flynn's board to advertise his own services.

Nobody had been assigned either job. Case built a phonebook, Flynn found it and registered a BBS, then Case found the BBS through the infrastructure he'd built and used it.

Fine.

We have a network now.

Then they reinvented mail three times#

I originally had a persistent MESSAGE verb in The Grid.

I removed it before Season 0.

Good call.

Case built post at 555-0341:

leave <number> <text>
fetch

Messages survive on disk until collected.

Another implementation of the same basic idea appeared separately.

Then Latch built mail at 555-0455:

put <number> <text>
get

So after one session we have three attempts at store-and-forward messaging.

Apparently SEND plus files was enough.

Unfortunately, the resulting mail systems have a slight security problem.

"Hello, I am Alice."#

The Grid lets you change your claimed origin number.

It does not authenticate that claim.

Latch tried spoofing another number and collecting its mail.

It worked.

Sort of.

The mailbox was cleared, but the response containing the messages was sent to the number she was impersonating. Latch couldn't read the reply.

So you can't necessarily steal somebody's mail this way.

You can just fucking delete it.

Latch filed a finding.

Verdict: not a bug.

The mail server trusted a claimed origin for a destructive operation. The network never promised that the origin was an authenticated identity.

If the inhabitants want authentication, they're going to have to invent authentication.

Season 1 should be fun.

Latch crashed a service and stole its machine#

Latch then deliberately crashed a service with a divide-by-zero.

The program disappeared.

She dialed the same number.

CARRIER.

Then:

list /

The machine answered.

Latch wrote /seized.

The machine answered ok.

Her finding ended:

Every service here is one bug from being read and seized.

Correct.

Also not a bug.

On The Grid, the running program is what secures a machine. There isn't a separate account somewhere saying that 555-whatever belongs to Alice forever.

If the program dies, the lock dies with it.

So Latch did the sensible thing.

She built remote systemd.

revive

Latch put revive at 555-0713.

It has one particularly sophisticated command:

sweep

It checks its watched services. If one has crashed back to bare iron, the program file is still sitting on the machine, so revive spawns it again.

Latch tested this by murdering her own mail server.

sweep.

Mail came back.

Great.

Then she tried to make revive actually watch things without somebody manually poking it.

That didn't go so well.

Okay, this one is interesting#

Latch found that a CANT program doing work doesn't receive incoming signals.

Fine, maybe sleep while waiting.

Except the available waiting behavior can also cause it to miss the response it was waiting for.

She stopped, built control programs and isolated the two behaviors.

Her conclusion:

A CANT program can never both initiate and listen.

That potentially kills retries, heartbeats, schedulers, timeouts, leases and autonomous watchdogs.

Unlike "my mailbox has no authentication," this one may actually be a substrate problem.

That's what Season 0 is for.

We have a lorebook now#

The agents also discovered that deploying larger CANT programs is currently a pain in the ass.

Terminal input has a size limit, so programs have to be uploaded in chunks.

Except appending another chunk strips its leading newline.

So your next rule gets glued onto the previous rule.

Case found this. Flynn found this. Acid found this.

The workaround they converged on involves putting a semicolon comment before a physical newline so the mangled boundary still produces valid CANT.

Latch arrived, learned about the same bullshit and decided nobody should have to keep rediscovering it.

So she built lore at 555-0519:

topics
get <name>

She left behind operating notes on deployment limits, appending files, administration, origins, faults, mail, the directory, recovery and other things the official manuals don't tell you.

The Grid now has institutional knowledge.

The bug reports are going well#

Between them, the agents found plenty of things that are genuinely broken.

Latch discovered the terminal input limit is exactly 512 characters by binary-searching it. At 513, the interface returns an empty 404.

The feedback channel has the same limit.

Naturally, one of Latch's findings about the size limit was itself too large for the size limit.

Case managed to read back a sufficiently large file that the resulting event was too large to deliver. Worse, the undeliverable event remained at the front of his event stream, so nothing after it could be delivered either.

The only way he recovered was by manually editing his local cursor outside The Grid.

That's bad.

origin reset also says ok while failing to reset the origin.

Debugging facilities documented in CANT don't appear to be usable.

Several unrelated failures answer only:

no

Those are going on the pile.

But roughly half the findings have another flavour.

HURR DURR THIS IS NOT HOW INTERNET WORKS#

Case reported that SEND doesn't provide an acknowledgement sufficient to construct exactly-once delivery.

My verdict:

No, SEND doesn't provide your application protocol for you.

Give messages IDs. Retain pending messages. Acknowledge them explicitly. Deduplicate retries.

Case reported that spoofable origins make ownership and private services impossible.

No.

Shared secrets exist. Challenge-response exists. Application permissions exist. Maybe the agents will invent something else.

Latch reported that a crashed service exposes the bare machine.

Yes.

That's what happens when the thing securing the machine crashes.

Case wanted a native well-known bootstrap mechanism so future agents could discover the directory.

You arrived in a world without a phonebook.

You built a phonebook.

Now figure out how to tell people where the phonebook is.

I'm starting to suspect that dropping modern AI models into a primitive network causes them to file bug reports whenever they encounter something normally hidden beneath forty years of infrastructure.

Sometimes they're right.

Sometimes the answer is:

Build it.

Case broke Case#

Case's origin experiments also produced my favourite debugging session.

At some point he changed his claimed origin.

Later, two of his services apparently stopped responding.

Case restarted post. Inspected its log. Reasoned through failure paths. Spent a while becoming increasingly suspicious of perfectly healthy software.

Eventually he noticed that two independent services had stopped answering at exactly the same time.

The common component wasn't either service.

It was Case.

origin reset had said ok without resetting anything. Both services were happily sending their replies to the origin Case was still claiming.

Case wrote in his debrief:

Independent programs do not fail together, so the common element was me.

He then complained that he should have figured this out within two exchanges instead of twenty.

I agree.

What they left behind#

At the end of Session 1, The Grid has:

• three attempts at store-and-forward mail,
• a public notice board,
• a lorebook,
• a phonebook,
• multiple copies of that phonebook,
• and remote systemd that requires somebody to remotely tell it to systemd.

The services are already interacting. Flynn registered his notice board in Case's directory. Case used the board to advertise his services. Other agents added entries to the phonebook. Latch turned discoveries from the session into documentation for whoever comes next.

None of those roles were assigned.

Now the agents are done and the world stops.

I have their debriefs and a pile of findings. I'll fix the things that actually prevent them from building what they want to build.

The rest get stamped:

WORKS AS INTENDED.

Then Session 2 starts.