A letter from Wilderness Interactive
Sovereign systems. Living software. Growth that compounds.
We’re an independent creative company building production software in Rust. Fourteen 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 I 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. This is from my family's recorded history, not speculative genealogy. It was done through letters and confirmations over generations.
It’s a working inheritance. I'm a HEMA practitioner, and a black belt in karate. If you've never heard of HEMA, it's about reconstructing historical fighting systems from their original manuscripts. In HEMA, we 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. At HEMA Penzance, with its amazing people who I can't say enough good things about, I train in Fiore dei Liberi’s fourteenth-century longsword, the way my forebears would have drilled their own traditions of swordsmanship before a campaign. I also apply Miyamoto Musashi’s Way of Strategy to everything I do. And I learn his longsword and dual wield the HEMA way too, studied and used in live sparring from his manuscripts, which is different from the school he created called Niten Ichi Ryu.
I've been a Zen Buddhist ever since I gained a deep interest in the state of flow as a teenager. I sought the answer in Zen after hearing an Alan Watts talk perfectly describe what I'd experienced. I've practiced Zen my whole life since then, and I made notes every day trying to understand it, until I eventually realized that Huang-Po was quite literal in what he said, after which I realized there's nothing to be afraid of in life anymore.
At university, I studied theoretical physics, and then sociology because both are really about the same thing (at least how I see it): complex systems emerging from simple rules, and taught Zen meditation classes on the side until I read Miyamoto Musashi's Book of Five Rings, which was another turning point for me. Applying his Way of Strategy, I sought to "cross the ford" for income directly, and took to writing marketing content and growing my own niche sites to dominate Google results for competitive buying-intent commercial terms, one of which reached $220k/mo revenue through Amazon alone, until position-one rankings and conversion copy stopped being a craft I did myself over and over again, and became a craft I could teach a language model to do for me. Once I learned Rust, I was no longer confined to just site work, and Wilderness Interactive was born. And I picked Rust so that I could borrow for myself the ways of doing things that the Romans did, as per Machiavelli's Discourses on Livy. Checks, balances and guarantees were the foundations the Romans built on.
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 already wrote myself. The work firms quote six months for, I've done in a day on my own platforms. 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 marketing, the Zen practice, all of it underneath every line of Rust. Emergence Engines are 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: this kind of click produces this kind of revenue, all the way to implant-and-crown depth.
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. The copy didn’t get cleverer; 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
Fourteen 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.
Your site, your code, your data, your accounts: all yours. The bespoke pieces we build for your business are yours too. If you ever leave, you take all of it with you. Our own products stay close to us, but everything we make for you stays with you. No vendor lock-in, no hostage clauses. 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 built by the same team.