Back to the Root Server

A Glitch in the Code

To understand the Glitch, we first have to understand the Master Code. And to understand the Master Code, we have to go back -  all the way back - to the Root Server.

Not Silicon Valley. Not Wall Street. Not any capital city on Earth. But the African savanna.

Because for hundreds of thousands of years, that’s where humanity spent its long childhood, surviving, enduring, evolving and becoming something very specific: the most sophisticated relational system on the planet.

We didn’t evolve to be the fastest. We didn’t evolve to be the strongest. We didn’t evolve with claws, venom, armor, or wings. What we evolved was the ability to manage relationships. Relationships with:

• other humans

• animals

• landscapes

• tools

• fire

• time

• weather

• memory

• and eventually… meaning

On the savanna, survival didn’t depend on how hard you could hit. It depended on how well you could:

• read someone’s intentions from their eyes

• remember who shared food with you last dry season

• recognize when someone was bluffing confidence

• coordinate silently during a hunt

• soothe a crying child that might attract predators

• share resources without encouraging freeloaders

• maintain alliances across years

• resolve conflict without losing group cohesion

That’s not brute intelligence. That’s relational intelligence. Your brain became a live simulation engine constantly tracking:

Who can I trust?

Who owes who?

Where did the herd migrate last season?

Who knows how to make this tool?

If I share now, will they share later?

Are they angry… or afraid?

In computing terms, the African savanna was our Root Server, the original runtime environment where our species’ cognitive architecture was configured. It’s where:

• trust thresholds were calibrated

• fairness instincts emerged

• cooperation norms evolved

• fear responses were tuned

• social group size limits stabilized

• parenting strategies took form

• status systems developed

• moral intuitions booted up

This is where the default settings for:

• empathy

• jealousy

• revenge

• generosity

• belonging

• exclusion

• leadership

• reciprocity

…were installed. This is where the core humanistic functionalities were coded into us. Now, here’s the key point: That code is still running.

Every modern institution - markets, corporations, political systems, online platforms - is operating on cognitive firmware that was compiled for small, interdependent bands navigating open grassland.

We are running Pleistocene social software on planetary-scale hardware. And sometimes… it doesn’t scale well. Our brains evolved to manage dozens of relationships, maybe a hundred and fifty at most — not thousands of online contacts, millions of strangers in megacities, or abstract systems distributing resources across continents.

We evolved to respond to immediate threats, not statistical risks. To value reputation, not anonymity. To cooperate with known individuals, not faceless institutions. To interpret tone of voice, body language, shared history, not text on a screen.

So when modern systems stretch those ancient relational capacities beyond their intended limits…We get distortions. We get misfires. We get mistrust where cooperation is needed. We get tribalism in a globally interconnected world. We get status competition without responsibility. We get outrage without reconciliation. We get fragmentation where cohesion once kept us alive.

In other words: We get the Glitch.

But a glitch isn’t a permanent failure. A glitch is what happens when a system encounters conditions it wasn’t originally optimized for. And systems can be debugged. Because the Master Code - empathy, reciprocity, shared attention, fairness, obligation - wasn’t deleted. It’s not gone. It’s still there encoded in our nervous systems waiting to be accessed. Waiting to be remembered. Waiting to be re-aligned with the environments we’ve built.

Going back to the Root Server doesn’t mean going backwards in time. It means understanding the original conditions our relational architecture was designed for and using that knowledge to redesign our institutions, technologies, and cultures so they work with our human firmware… not against it.

The Glitch can be fixed. It´s not that complicated. We just have to remember how we were coded.

Thanks for reading. Abrazos.

Diego Rojas