Back to Blog

The Seldon Engine — Open-Source Psychohistory

March 15, 2026•16 min read
Agents
Open Source
Opinion

The seeing stones

Palantir Technologies named itself after Tolkien's palantíri — the seeing stones of Middle-earth. In the novels, those stones were neutral instruments. They became dangerous because one entity controlled the network. Sauron held the master stone. Anyone who used a palantír risked being seen by him, manipulated by him, shown only what he wanted them to see. The power wasn't in the seeing. It was in the asymmetry of the seeing.

For twenty years, the company has operated the same way: centralized intelligence infrastructure where your data flows to their platform, your analysis runs on their systems, and your access depends on their continued cooperation. The moat, according to its co-founder, is not the data. It's the analysis layer — the expertise encoded into hundred-million-dollar systems that can't be replicated by a weekend of prompts.

Then someone replicated the observation layer in a weekend. And the analysis layer started looking thinner than anyone expected.

Bilawal Sidhu — former Google Maps PM — posted a demo of a browser-based OSINT fusion platform called WorldView. Real-time aircraft, vessels, satellites, internet-connected devices — the full intelligence aesthetic, running in a browser tab. He built it in a weekend with AI coding agents.

Someone joked he'd "vibe-coded Palantir." Joe Lonsdale — Palantir co-founder — responded within hours. His position was dismissive: you don't understand what companies like Palantir actually do if you think you can vibe-code them. Defense is the worst market for what vibe disrupts. The things getting disrupted are low-end SaaS — companies that put more money into sales than engineering. Hundred-million-dollar systems aren't getting replaced by a weekend of prompts.

Then the Iran strikes happened. Sidhu sent a WhatsApp message to his AI agent and told it to start recording every open-source signal before the caches cleared. By evening he had a full 4D reconstruction of Operation Epic Fury — not just airspace closures and GPS jamming, but satellite-by-satellite correlation of which nations were imaging the strike zones before and after impact. American KH-11 Topaz passes over the nuclear sites. Russian Persona-3 surveillance satellites. Chinese Gaofen synthetic aperture radar. Commercial constellations from Maxar, Capella, and Airbus stacking up over the targets. He mapped the electronic warfare environment by aggregating navigation confidence drops from commercial aircraft — every plane reporting GPS degradation became an unwitting sensor. He tracked 3,400 flights clearing Iranian airspace, cascading no-fly zones across nine countries, the Strait of Hormuz closing, and retaliatory strikes hitting US bases in Bahrain and Qatar. All from public data. All in a browser. All replayable minute by minute on a 3D globe.

His commentary afterward was pointed: it's amazing what you can build without "proprietary data fusion."

Lonsdale never conceded anything. But the demonstration did the work his words wouldn't. Defense tech founders started contacting Sidhu, telling him his visualization capabilities exceeded systems the Department of Defense was actually buying. The same data feeds that required classified clearances a decade ago — aircraft transponders, vessel AIS, satellite TLEs, internet-connected devices — are now public APIs. Layer them on a CesiumJS globe and you have something that looks like a joint common operating picture running in Chrome.

Lonsdale's actual defense — that the analysis layer is Palantir's value, not the data — is the more interesting claim. Because it's correct in a narrow sense. Observation isn't prediction. Knowing where every aircraft is right now tells you nothing about what happens tomorrow. But Sidhu wasn't just observing. He was correlating satellite passes with strike timing, inferring electronic warfare from signal degradation, reading the negative space where transponders went silent. That's analysis. And he did it over a weekend.

The observation layer is commoditized. The question Lonsdale should be asking isn't whether anyone can replicate Palantir's analysis. It's whether anyone can get from seeing to predicting — and whether the tools to do it are already public.

The prediction problem

The standard toolkit for prediction — regression, time series analysis, Monte Carlo simulation — works from historical distributions. It extrapolates patterns from data about what already happened. This works for systems that are stationary or change slowly. It fails for the phenomena that matter most.

Information cascades. Opinion polarization. Viral tipping points. Market panics. Electoral shifts. These are emergent — they arise from interaction dynamics between agents, not from historical curves. A time series model trained on polling data can't predict the moment a political narrative tips because the tipping isn't in the data. It's in the network. Statistical models treat emergence as noise. That's the gap.

Asimov saw this clearly. Psychohistory — the mathematical framework in the Foundation series — doesn't predict individuals. It predicts what emerges from their aggregate interactions. Seldon's equations model the statistical mechanics of human societies the way thermodynamics models gases: individual molecules are unpredictable, but the ensemble has laws. The math operates on the collective, not the particular.

Nobody has Seldon's equations. But the computational approach they imply — simulate the agents, watch what emerges — now has a working implementation.

The simulation layer

MiroFish is the first open-source system that attempts prediction through emergent social simulation at scale. Not the only agent simulation framework — but the first to wire ontology generation, knowledge graphs, agent populations, and social platform simulation into a single prediction pipeline. The architecture is what matters, not the brand.

Feed it seed material — news articles, policy drafts, financial data, opinion reports — and it constructs a parallel digital world populated by thousands of LLM-powered agents. Each agent has a distinct personality, long-term memory, behavioral parameters, and social media behavior. They interact on simulated Twitter and Reddit clones. The prediction doesn't come from a statistical model. It emerges from what the agents do.

The pipeline is concrete: ontology generation from seed text, knowledge graph construction via GraphRAG, agent profile generation with MBTI and behavioral parameters, dual-platform simulation on CAMEL-AI's OASIS framework, and a ReACT-pattern report agent that can interview individual agents about their perspective. The knowledge graph evolves during simulation — agent behavior generates new knowledge that shifts subsequent behavior. Temporal feedback loops.

They demonstrated it predicting the lost ending of Dream of the Red Chamber — a classical Chinese novel where the final forty chapters are disputed. Feed the first eighty chapters as seed material. Spin up agents representing the characters. Let them interact. Watch what emerges. The prediction isn't computed by a model trained on literary criticism. It emerges from simulated social dynamics between agents who embody the characters.

The architecture runs. It produces outputs that can be evaluated. But who tunes it? The ontology, agent parameters, personality distributions, simulation duration — these are all hand-configured. Whether MiroFish predicts accurately depends entirely on configuration choices that nobody knows how to make yet. The system runs. Whether it's right is a function of decisions its operators make without a systematic way to evaluate them.

The reflexivity problem

Before solving the tuning problem, there's a deeper constraint any serious prediction architecture must address.

Asimov understood the failure mode. In the novels, psychohistory only works if the population being predicted doesn't know about the predictions. The Seldon Plan is kept secret specifically because awareness would change behavior and invalidate the forecast. The Second Foundation exists to course-correct when the Plan drifts — a hidden calibration layer operating on the system from outside.

This isn't just a fictional conceit. If a simulation predicts a market crash and traders act on it, the crash either happens faster or is averted entirely. The prediction changes the thing it predicts. George Soros built an investment philosophy — reflexivity — around exactly this dynamic. Any prediction system powerful enough to be useful is powerful enough to invalidate itself.

But the objection dissolves under closer examination.

The question "does prediction change what it predicts?" presupposes a stable object being predicted. In practice, the object — collective human behavior — is already in constant flux. Every piece of information already changes behavior. News reports change markets. Polls change elections. Weather forecasts change whether people carry umbrellas. Prediction doesn't introduce reflexivity into a system that was previously non-reflexive. It adds one more signal to a system that is already composed entirely of signals.

The computational answer to the Seldon paradox isn't secrecy. It's recursion. A prediction system that models its own influence on the system it predicts — that treats its own outputs as inputs to the next simulation cycle — doesn't need to be hidden. It needs to be self-adjusting. The prediction accounts for the fact that the prediction exists.

This reframes the tuning problem. The simulation's parameters can't be set once and left alone — not just because we don't know the right values, but because the right values change in response to the simulation's own outputs. The system needs autonomous optimization that runs continuously against a moving target. And it needs external ground truth to calibrate against, because a reflexive system cannot evaluate itself from inside.

Two open-source projects, released within the same month as MiroFish, address exactly these constraints.

The optimization layer

If the simulation's parameters need continuous adjustment against a target that moves in response to the simulation itself, you need an optimization loop that runs without human intervention.

Andrej Karpathy released autoresearch on March 6th. The concept is radical minimalism: three files. prepare.py handles data and evaluation — read-only, nobody touches it. train.py contains the full GPT model and training loop — the AI agent modifies this. program.md contains the research methodology — the human writes this.

The human programs in Markdown. The agent programs in Python.

The loop: establish a baseline, modify the code with a hypothesis, train for exactly five minutes, evaluate. If the metric improved, keep the change. If not, reset. Log to results. Repeat indefinitely. No human in the loop. The agent runs overnight. You wake up to a log of experiments and — if the constitution was well-written — a better model.

The fixed time budget is the key design constraint. Every experiment runs for exactly five minutes regardless of what the agent changed — model size, batch size, architecture, optimizer. This makes all experiments directly comparable. The system doesn't search for a universal optimum. It searches for the best outcome given real-world constraints.

What makes this relevant to prediction isn't the ML training. It's the meta-level recursion. The real optimization isn't finding better hyperparameters. It's finding better processes for finding better hyperparameters. program.md — the research methodology itself — is the variable under optimization. Karpathy described the vision: multiple agents, different constitutions, different regions of search space. Swarm-based exploration of methodology.

Generalize this beyond neural network training and you have an autonomous optimization loop for any system where evaluation can be formalized. Which agent personality distributions produce accurate predictions? Which ontology structures capture the right dynamics? Which simulation parameters best match reality? Don't hand-tune them. Let an autonomous agent search the space.

The loop needs a loss function. In neural network training, that's validation loss — a single unambiguous scalar. The agent knows immediately whether it improved. In social prediction, what's the equivalent? Where does the ground truth come from?

The calibration layer

Polymarket isn't a repository. It's a running prediction market — real money, real probabilities, real resolution data. And it answers the question the optimization loop is asking.

Prediction markets aggregate distributed private information through price discovery. Participants with domain knowledge — industry insiders, analysts, experts — express their beliefs by risking capital. The price encodes information that no single participant possesses. Friedrich Hayek described this mechanism in 1945: markets transmit knowledge that can't be centralized because it exists only in distributed form. Polymarket operationalizes this for event prediction.

The connection to observation isn't a domain jump — it's the same function through a different mechanism. Sidhu aggregates sensor data from public feeds to reconstruct what happened. Polymarket aggregates private beliefs through financial incentive to predict what will happen. Both are information aggregation systems. The mechanism differs; the function is the same.

What Polymarket provides for this architecture is ground truth. MiroFish generates predictions through simulation. Polymarket generates predictions through market aggregation. The delta between them is the calibration signal.

Make it concrete. Polymarket runs a contract on whether the EU will impose new AI regulation by Q3. The market sits at 62 cents — 62% implied probability. You feed the draft regulation, industry lobbying disclosures, and recent parliamentary debate transcripts into MiroFish as seed material. The simulation spins up agents representing MEPs, tech lobbyists, civil society groups, and member state delegations. They interact. The simulated vote lands at 78% probability. The delta — 16 points — is your signal. Either the simulation is capturing dynamics the market hasn't priced in, or the simulation's agent parameters are miscalibrated. Run it against twenty markets simultaneously. Track which simulation configurations predict resolution correctly. Now you have a loss function.

That's what closes the loop. Did the simulation outperform the market? Did the prediction resolve correctly? How early did the signal appear? These are scalar metrics. They drive the optimization.

The composition

Each section arrived here because the previous one left a question unanswered. Observation doesn't predict. Statistical prediction misses emergence. Simulation captures emergence but can't tune itself. Reflexivity means the tuning target moves. Optimization needs ground truth. Calibration provides it.

The feedback loop runs end-to-end: observation feeds seed material into the simulation. The simulation generates predictions. Calibration against prediction markets provides ground truth. Optimization adjusts the simulation parameters. The cycle repeats. Each pass refines the system's model of collective behavior — including the system's own influence on that behavior.

Add the observation layer — real-time OSINT data feeding seed material, predictions rendered as projected overlays on a common operating picture — and the architecture becomes concrete. Not just what's happening now, but what the simulation projects will happen next, calibrated against market consensus, optimized autonomously.

That's the Seldon Engine. Not as metaphor — as architecture.

The acceleration

Every claimed moat erodes the same way, and each erodes faster than the last.

The model is not the moat — distillation attacks proved that. A frontier model's capabilities can be extracted into something smaller and cheaper within months. The data is not the moat — Lonsdale admitted as much by defending the analysis layer instead. Sidhu proved it empirically by reconstructing a military operation from public APIs. The analysis layer is not the moat — expertise encoded as methodology is exactly what an autoresearch-style loop optimizes. If the evaluation function exists, the methodology can be searched autonomously. Composition is not the moat — the observation layer is a weekend project, and wiring prediction on top of it is an architecture document away from a prototype.

The pattern isn't that moats fall. It's that they fall faster each time. Each commoditized layer becomes infrastructure for commoditizing the next. Open models make it faster to build analysis tools. Commoditized data makes it faster to test composition. The tools build tools. The rate compounds. There is no layer where the acceleration stops, because every layer that falls makes the next one easier to take.

This creates a sovereignty problem. If every layer gets commoditized, the only defensible position is the specific instantiation — your data, your expertise encoded as evaluation functions, your operational context, running on infrastructure you control. The architecture is public. The configuration is private. The tools are commodities. The use is not. A thousand organizations can clone the same repositories. What they feed them, how they evaluate the output, what counts as a good prediction in their domain — that's where the differentiation lives. And it's not abstractable. It's not a layer you can commoditize because it's not a layer at all. It's the specific relationship between the operator and their context.

An opening

Every piece of this architecture is open-source, documented, and running. MiroFish has over ten thousand stars and an AGPL license. AutoResearch has over thirty thousand stars and an MIT license. Polymarket publishes resolution data through a public API. The observation layer runs on public data feeds that anyone with an internet connection can access.

None of this can be recalled. The Seldon Engine pattern — observation, simulation, optimization, calibration — is permissionless. It doesn't require approval, funding, classified access, or institutional affiliation. It requires a laptop, some API keys, and the architectural imagination to compose what's already public. Once someone publishes the composition — once the first working prototype hits GitHub — it forks. It adapts. It takes on a life of its own, the way every sufficiently useful open-source project does.

The company named itself after the seeing stones. The irony is structural. For twenty years, the palantír network was centralized — one entity controlled the platform, the data flowed to them, the analysis ran on their terms. Now the stones are being distributed. A thousand independent instances, each looking at the same world from a different angle, running on different data, optimized for different definitions of accuracy, controlled by no central authority. No Sauron. No Second Foundation. No single entity that decides what gets predicted and who gets to see.

Asimov imagined psychohistory as a mathematical framework developed by a single genius over decades. The computational version — if it exists — will be assembled from open-source components by people who read science fiction as children and grew up to find the repositories waiting for them.

Whether the Seldon Engine works is an empirical question. Whether it can be stopped is not.

That's not a conclusion. That's a starting condition.

Sources

Related Posts

X
LinkedIn