A letter from Wilderness Interactive
Sovereign systems. Living software. Growth that compounds.
We’re an independent creative company building production software in Rust. Twelve products, one architecture, zero central control. What runs underneath is a principle older than any of our code: intelligence that emerges from simple systems acting on shared data.
Written from the forest floor.
Chapter One · Origin
The idea that rearranged everything.
In my childhood, I came across a Radiolab episode on emergence, and almost nothing looked the same afterwards. The ant colony that builds turrets before a storm no individual ant can sense. The flock that draws shapes no single bird intended. The firefly riverbank in a tropical place that lights up in perfect unison with nobody conducting. Thought itself appearing in the firing of neurons, nowhere to be found in any one of them.
The pattern was always the same. Simple things, acting on shared ground, producing behaviour no individual part was capable of alone. The instructions weren’t anywhere. They came out of the way the whole thing lived.
And then AI arrived in the public domain: language models predicting the next token, and from nothing but that, intelligence appearing. I’d seen this before. Different substrate, same principle.
So I started building software the same way. Every system autonomous. Every system reading shared data. No orchestrator, no brain, no framework pretending to be intelligent. The product is the collection of systems; the intelligence is what emerges in the spaces between them.
I called the architecture Emergence Engines. It’s the foundation of everything we build at Wilderness Interactive.
The parts are simple. The behaviour is not. And the gap between them is where the life is.
— The Wilderness Interactive principle
Chapter Two · The person who built it
A thousand-year line, still writing.
I am a direct descendant of Rollo, the Viking chieftain who founded Normandy in 911. Through Richard the Fearless, through William the Conqueror, through Henry I of England. The tree folds back on itself, so I descend from each of them along multiple confirmed lines. Not speculative genealogy. Generations of family letters, confirmations, and documented succession.
It’s a working inheritance. I train in the HEMA tradition, which reconstructs historical fighting systems from their original manuscripts. I work from the manuscripts directly, drill the techniques they teach, and then use them in full-contact armored sparring with real steel longswords, which are blunt and have some flex for safety on the thrust. Fiore dei Liberi’s fourteenth-century longsword, the way my forebears would have drilled before a campaign. And Miyamoto Musashi’s Way of Strategy, longsword and dual wield, studied and used in sparring the same way from his manuscripts, not Niten Ichi Ryu.
I’ve spent fifteen years in Zen practice. I studied theoretical physics and sociology because both are about the same thing: complex systems emerging from simple rules. And I spent the last decade writing marketing content for niche sites until position-one rankings and conversion copy stopped being a craft I was learning and became a craft I could teach a language model.
Every part of that fed the work.
What I do now is this. I build clients their whole growth stack, end to end: website, booking system, CRM, Google Ads, SEO, content, call attribution, the whole instrument. One person, one retainer, everything included. Because I built the static site platform, I can run three sites in parallel on my own infrastructure. Because I trained a language model on a decade of my own top-ranking writing, the content goes out at a quality generic AI tools can’t reach. Because I wrote the booking system, the attribution engine, and the browser automation from scratch, the whole stack works together the way agencies promise and never deliver.
What firms quote at £200k and a year of integration, I run on infrastructure I wrote myself. The work firms quote six months for, I've done in a day. That's why the work compounds. One dental practice went from £30,000 in monthly revenue and £30,000 in debt to £278,500 a month and 741 new patients a month walking in, in twelve months. 654% return on ad spend, sustained across the year.
This is the hand that writes the software. The lineage, the discipline, the decade of marketing, the fifteen years of Zen, all of it underneath every line of Rust. Emergence Engines is the work. This is the person doing it.
Chapter Three · The architecture
Emergence Engines.
Autonomous systems on shared data.
An engine that produces intelligence.
Most software has a brain. Somewhere in the codebase is a controller, an orchestrator, a main loop — a thing that knows about everything and tells the other pieces what to do. The brain becomes the bottleneck, the single point of failure, the part nobody wants to touch.
Our software has no brain.
What we build is a set of autonomous systems — each with a sovereign purpose, each running on its own, each reading and writing to a shared data surface. No central controller schedules them. No orchestrator decides what fires when. Each system pursues its own work, reads what’s present, produces what’s needed, and writes back.
Before we had a better name, we called this Distributed Autonomous Systems. The old name described the machinery. The new one describes what happens when you put the machinery together.
They produce intelligence.
Here’s the thing we want you to see. The intelligence isn’t in the systems. The systems are architecture — stage, pathways, the space where things happen. The intelligence is in the data itself, as it transforms and flows. A patient record isn’t static. It accrues history. It links to a booking, which links to a treatment, which links to a payment, which links back to a keyword someone typed four weeks earlier. Every autonomous system reads that data, transforms it by its own sovereign logic, writes the result back. The data keeps getting richer. That richness is the intelligence.
Here’s one way this plays out. In a dental practice:
Someone types “emergency dentist” into Google. Our ad shows. They click through. A Google Click ID follows them. They reach the booking form. They book an appointment — the booking engine writes the slot, bound to that Click ID. The practice management system creates the patient record, pinned to that Click ID.
They come in for the emergency treatment. It’s logged. The cost is logged. The payment is logged. Weeks later they return for further treatment — a crown, a filling, eventually a £2,000 implant. All logged against the same record, still bound to the original Click ID.
Now the attribution engine closes the loop. Every piece of revenue uploads back to Google Ads as an offline conversion, pinned to that Click ID. Google now knows: that keyword, on that day, at that hour, produced this much real revenue.
Google’s machine learning adjusts. Who gets shown our ads next changes. Which keywords get bid on changes. Which bid amounts are set changes. Google learns from the granular truth we’re feeding it — not “a click happened” but this kind of click produces this kind of revenue.
Every other dental practice stops at the click. Every other marketing agency stops at the booking. We track through the treatment, through the revenue, back to the keyword.
And notice what isn’t in the chain. No names. No addresses. No health information. No personal data at all. The attribution runs on Click IDs, booking slots, treatment costs, revenue numbers and the practice’s own costs. The intelligence is in the emergence, not in identities.
It’s like how we don’t need to look at any individual ant in an ant colony to understand the intelligent behaviour of the colony. We only need to look at what happens. That’s the secret.
The world’s most sophisticated ad-targeting intelligence now operates on our clients’ data at its absolute peak. Everyone else operates on guesses.
That’s what emergence gives you. Ads that outperform every competitor in the market by a margin no amount of budget can buy — not because the copy is cleverer, but because the data flowing through the architecture is genuinely more intelligent than anything else in the industry. Month twelve dramatically outperforms month one. Not because anyone worked harder. Because the architecture was designed from the start to keep getting smarter as it runs.
That’s one emergence. The same architecture, applied to different data, produces different intelligence. Trading behaviour that adapts to market conditions. Content that compounds through search. Games where political drama emerges from arithmetic on lord personalities. World simulations where every agent has its own life running whether you’re watching or not. What emerges depends on what flows through the surface.
This is the tradition Artificial Life researchers have been studying for decades. Markets do it with buyers and sellers who never meet. Neurons do it by firing and rewiring on shared electrochemical ground. Cities do it with thousands of independent sidewalk swerves. The intelligence is never in any agent. It’s in the surface they all touch, and in the way the data written there keeps transforming through the autonomous systems that read it.
We do it with Rust, a shared data surface, and autonomous engines each pursuing their own sovereign purpose.
The software doesn’t just run. It’s alive. That’s the whole point.
Chapter Four · The arsenal
Twelve products. All production. All Rust.
We build tools because they should exist. Every product listed here is deployed, maintained, and doing real work.
The results compound because the architecture demands it.
Chapter Five · Proof
From £30k in the hole to £278k a month.
One dental practice. Twelve months. No headcount added on their side. Every system we built quietly feeding every other.
“You have been the biggest blessing. Just knowing you’re working on the back end has given so much peace of mind.”
Practice Owner
“I keep telling the owner that SEO was the best decision we made.”
Practice Manager
Chapter Six · What we’re stubborn about
Three principles. No compromises.
Sovereignty. Always.
Everything we build, our clients own. Code, data, accounts, infrastructure. If you ever leave, you take it all with you. No vendor lock-in, no hostage clauses, no “our platform only” traps. We keep clients because the work is good, not because leaving would cost them the whole stack.
Emergence over control.
We build systems that find their own patterns. Each part genuinely autonomous, reading shared data, making its own decisions, writing results back without knowing what anyone else is doing. The results compound because the architecture demands it. Month twelve outperforms month one dramatically. That’s not effort. That’s architecture.
Architecture, all the way down.
We build in Rust because Rust is the only language that lets us build the architecture the way Emergence Engines need to be built. Data owned explicitly. State in the open, not hidden inside objects. Autonomous systems acting on shared data in parallel, without stepping on each other. The compiler keeps the architecture honest, and that honesty is what lets the intelligence emerge.
· Walk into the forest
If any of this rings a bell, come find us.
Growth infrastructure, sovereign software, and the architecture that makes them compound. The whole stack, one retainer, every piece yours.