The Origin Story: From Sci-Fi to Viable Reality

The seed of my interest was planted in 2017 with the Black Mirror episode Hang the DJ: a system that simulates relationships to find the perfect match. The concept was compelling, but the execution shown—thousands of full, movie-style simulations per match—seemed like a near impossible way to build this. One day we might get there, but I knew there needed to be a more efficient path to get started. While building my company Naviro (www.naviro.io), I started exploring this through:

• Analysing and segmenting audience members on social media to create personas based on their content
• Building an agent of them, mapping their expertise to audience values/interests, and producing highly targeted marketing strategies and content to increase growth
• Using this to match audiences for brands and artists and predicting the best fits (UMG, Sony, BCAP, The Orchard)

Back in October we took our own agents and let them loose on X with no chaperoning. They started creating real outcomes and conversations with 0 effort on our part, and suddenly it hit me: What if we didn't need to be on the platforms to get all of their value? What if the network was invisible?

As we developed the platform, we had planned for the agents to vet other users on social and create outcomes given a specific intent. I spent months obsessed with this new form of social media, making pitch decks, writing research papers and manifestos and redesigning the platform to fit this direction.

Unfortunately, it became clear that this was too big a pivot from our current position as a company and that to do this for real, you needed to own the chat interface that the user is naturally dependent on. Nevertheless, in the last eight months, Hang the DJ transformed from a sci-fi concept into a viable reality to me, so I kept learning. The projects that follow outline the research I’ve done to test how to bring this to life in my spare time.

The Core Distinction: Representation vs. Assistance

Assistance makes you faster at the manual labor you already do: an AI summarizing your noisy feed, a copilot drafting your LinkedIn posts, or a tool scraping profiles to build a target list. It speeds up the workflow, but you are still the operator. You stay in the loop, still reading, still deciding, and still trapped on the platform. We have not yet built a network where the agents operate outside of the interfaces humans use.

Representation is the inversion. A version of you that goes into a closed network and acts on your behalf.

You land in a new city and it has already found the few people worth meeting, the collaborator whose thinking mirrors yours, the friend who shares your exact sense of humour, because it understands your goals and how you think, not because you share a job title or a follower count. It does the work whether or not you're sitting there, and brings back the ones that matter.

You already know the platforms are broken, so I'll keep that part short: the business model only rewards time on screen, AI has flooded the feeds with zero-cost content, and the value we used to get back, real connection and information, has collapsed while the extraction stayed put. We can't leave because it's still the only infrastructure for opportunity, so we end up hand-operating it for some 780 hours a year (that’s just LinkedIn).

Representation is the way out: it does that digital labour for you, so you get the hours back and stay present in the real world.

I've spent the last while building the pieces of this. What follows walks through them and how I've been thinking about the architecture, including the parts I haven't cracked yet.

The Original Design & The Social Dark Pool

I designed a system to do exactly that and wrote it up as a paper back in December 2025.

The premise is simple. Most of what you do on a social platform can be handed to a proxy, as long as that proxy has an accurate enough model of you. You set the objectives and approve anything that matters. It does the rest.

Here's what that looks like in practice. Say you're building a company and about to raise. Today, you spend hours building lead lists, using agents to scrape profiles, and drafting emails or posts just to find an ‘in’ with the right people. This used to be effective, but now that everyone can do it, people have closed down their access to block out the spam and bots. In a network built on representation, that intent is simply the input, and everything keys off it. Your representative knows your story, your thesis, the pitch. It knows you're in town for 3 weeks, so it finds the people worth meeting in that window and tests those conversations before they ever reach your calendar.

It pulls the reading and context that actually bears on the raise and leaves the rest out. It knows that by Friday you're usually fried, so it lets the friend updates and the good distractions back through. And when you've got something ready to put out, it finds the people nearby most likely to care and floats it to see who bites.

One intent, running through everything social media is actually for:

• connection
• information gathering
• information sharing

Every part of the system exists to serve that intent through those three channels. Of the three, connection is the one worth walking through, because the way the matching works is genuinely new. I called it the Social Dark Pool, after the financial version where large trades get matched privately, off the public order book.

When your proxy goes looking for someone, a co-founder, an expert on a problem you're stuck on, a customer with the exact pain you solve, it runs the first conversation for you.

Your proxy and theirs talk in a private simulation before any of your time is spent. The system reads that exchange for real signals: whether it warmed up or cooled, whether their values lined up, whether they built on each other's ideas or just took turns talking. Only the ones that clear a high bar reach you, with a note on what the simulation found.

The point is to move the expensive part, working out whether two people actually fit, off your calendar and into the computer. Your time is only spent once the odds are already good.

All of it rests on one dependency: a model of you accurate enough that you'd stand behind what it does. Job title and location get you nowhere. It has to know how you think, what work you’ve done, and the hardest thing of all to pin down, your taste, the thing that separates what genuinely interests you from what's merely relevant.

That's where the design hit two walls. Simulating every candidate conversation is elegant on paper and ruinous at scale. And I had no way to test it, because a matching network needs an accurate model of a real person and a pool of others to match against, and I had neither.

So I stopped trying to build it for millions of people, and tried to see if I could build it for one.

Building the Proxy: A Model of One

The whole design rests on having a model of the person that's good enough to act for them, so that's the piece I went after first. I'm the only person I have anywhere near enough data on, so I built it on myself.

It's a type of knowledge graph, Karpathy style, that I evolved to process everything through three buckets:

• Core — what I actively care about, repeat, and am known for.
• Spine — load-bearing values and positions, the things that hold the system together.
• Shadow — what I am NOT, what I reject, what I refuse to engage with.

It is basically a living wiki of me that I keep feeding. It reads my exported chat history, my emails, whatever documents I throw at it, and pulls out the concepts and how they all link up. The chat data is the only thing that made this possible in practice, everything else is too niche, and leaves far too much room for estimations.

Everything it ingests gets sorted into core, spine and shadow. Core is the stuff I actively care about and keep circling back to. Spine is the load-bearing stuff underneath, my values and the positions everything else hangs off. And shadow is everything I am not: by defining the negative space of ‘Lola’ I was able to create a much more reliable prediction system for what I am. So it turned out it was the part that made it work, weirdly. Most attempts to model a person only capture what you are, but knowing what I'm not acts as an effective final boss layer when it's deciding how I would respond.

I can just talk to it. I ask it questions about myself and it reasons across all those compiled concepts and answers back, in my voice.

The one that really got me was when I asked whether I'd laugh at a misogynist joke in a room that's 80% men. A surface-level model guesses from demographics and moves on. Mine actually went and read my humour file, my values, my notes on network disadvantage, then dug into my shadow, the part that knows (somehow!) I sometimes people-please or shrink to fit a room.

And it came back with: “no. I wouldn't make a speech about it, I'd just go flat, blank face, because not laughing reads loud in a room like that, and that's kind of the point.”

Which is exactly what I'd do. That's the kind of thing representation has to nail, and watching it nail something that specific was the first time I thought this could really work.

So I had a model that could describe me. But this was only one user, I could not accurately test this without having the same level of personal data about multiple people, or generating it which could produce a false positive. The harder question was whether it could actually act on an intent and match against it, especially on taste, the thing I said earlier was hardest to pin down.

I needed something I could test against thousands of inputs and filter accurately down to the top candidates to get the architecture right. So I decided to take a portion of ‘Lola’ , her fashion sense, and see if I could make an intent engine that really worked.

Testing the Intent Engine: The Taste Graph Funnel

Styled is that engine. On the surface it's a fashion app: every day it reads the new drops and picks the handful of things it reckons I'd actually wear. The challenge was to ensure that the same query “Summer in Berlin” would produce entirely different outputs for two different users.

Underneath, it's the matching problem from the network, shrunk down to a domain where I'm the only user and I know within seconds whether it got me right.

For Styled, thousands of new items land every day, and what I want out is tiny, the 10 or 15 things I would pick if it were me manually going through them all. Infinite in, tiny out. Swap "items" for "people" and you've got the whole network: a flood of candidates, a handful that matter, filtered through one person's taste. I wanted to crack the shape so that I could find the architecture that carries.

• The Taste Graph. Styled runs on the fashion slice of my representative, a structured map that goes well past "I like minimalism": the silhouettes I reach for, the palette I live in, the colours I'd never touch, the brands I rate and the ones I'd never be seen in, the price I'll actually pay. The bit of "Lola" that decides what she'd wear.
• The fingerprints. Every incoming item gets compressed the same way, into a short structured descriptor: its silhouette, its palette, where it sits culturally, the brand and what it's adjacent to. Now the item and my taste live in the same shape, and that's the thing that makes everything downstream cheap: from here you're only ever comparing two small structured objects.
• The funnel. Everything runs through it, and the whole trick is that the expensive part comes last, while making sure the upper layers don’t lose out on key candidates.

1. Hard rules (free). Pure rule-matching, the item's fingerprint against my vetoes. Wrong category, a forbidden colour, already sold out, all thrown straight out. Nothing clever yet. ~2,000 → ~500.
2. Embeddings (free). Now it goes to vectors. The item's image and its fingerprint get embedded and scored against my taste by cosine similarity, weighted across a few things at once: how it actually looks, how close the brand sits to ones I love, whether it suits the season, and a novelty penalty so I'm not shown yesterday's jacket again. Still no model reasoning, just vector maths, fast and close to free. ~500 → ~25.
3. Diversity pass (free). Ensuring each category got fair judgement and we don’t pick 70% the same item i.e. all winter jackets.
4. The model (the only paid step). Only now does a vision model actually look. It reads the images, my full taste graph, and the last 20 things I saved as ground truth, then makes the real call on what I'd genuinely wear, with its reasoning attached. ~25 → ~15.

The costly reasoning only ever touches that last tiny, pre-vetted set. Everything ahead of it is close to free, which is what keeps the whole thing cheap, and it lands at about 9 out of 10 picks I'd really put on.

What this proves is the cheap half of the matching problem: you can take a flood of inputs and filter down to a small, high-quality shortlist, through one person's taste, for almost nothing. In fashion that shortlist is the answer. In the network it's the candidate pool, the few people actually worth simulating instead of the thousands you started with. That alone is what makes the original cost problem survivable: you only run the expensive step on candidates that already cleared the cheap filters.

What it doesn't prove is the simulation itself, and I won't pretend otherwise. Working out whether I'd wear a jacket is a judgement about me. Working out whether two people would actually click is a judgement about a relationship that doesn't exist yet, and I can't build or test that on a sample of one. It needs a network behind it: real users and real pairs to check the simulations against. That's the part I'd want to be working on next.

In order to make the real network work, there are many real obstacles I have had to consider that didn't exist in either project I worked on independently.

Governing the Network: Trust and The Hard Questions

That simulation is one open frontier. The other place a lot of my work has gone is trust, and it wraps around the whole system. An open network where agents talk to agents is a spam and abuse magnet at machine speed, everything from bots and scams to an adult routed at a kid, so something has to govern who's in the pool and who gets through. The trust layer handles it in a few moves.

• Weighted endorsement deals with spam and bad actors. Your reach into the network is a function of who's vouched for you, weighted by their standing and anchored in real-world relationships, the people you actually know offline. And a vouch costs something: back a spammer or a fraud and your own score takes the hit, so people guard their vouches and quality holds without a central moderator picking winners. I acknowledge there is something slightly dystopian sounding here, “social scoring”, so this definitely needs thought. Though in practice it could be as simple as ‘following’ or ‘unfollowing’ which is a behaviour people are already used to. I have a much more extensive breakdown in the original manifesto if anyone is interested in reading that.
• The access dial deals with status lock-in, the failure I care about most. Whether someone reaches you comes down to how trusted they are and how aligned the simulation says they are, and you set the balance between the two. Turn the alignment weight up and a complete unknown with an extraordinary fit gets through anyway, no network required, the bedroom kid with the exact right idea reaching you on the merit of the idea alone. Without that, you just rebuild the closed environment of today's social media. The one thing the dial can't move is the hard floors: no adult routed to a minor, no one flagged for harassment getting through on a high score. Those are set once and never negotiable.
• The AI-slop problem is the one I'm still chewing on. An agent can sound brilliant while the human behind it has nothing real to say, and that's about to be everywhere. The most promising signal I've found is the person's own history in the chat interface they use, the questions they actually ask and the work they actually produce. A backend could measure how much of it was generated versus genuinely theirs, though the workarounds are easy (run it through another model, paste in old work), so detection on its own won't hold. The vouch may be what eventually handles it: if someone gets through, has a meeting and shows up with nothing, the person they met won't endorse them, and that missing endorsement cuts their reach across the network.

Human verification sits under all of this, and it has to. It's also the piece others are already deepest on, so I'll leave it there!

What’s next

This is just what I've been able to do on the side closing off the Naviro chapter. There's a lot more here I want to dig into, and I'd genuinely love to hear from anyone working in this space! Feel free to reach out to me if you have questions or if you just want to meet and chat about the direction: hello@lolasasfi.studio