PLATO
Local-first intelligence substrate -- 87 engines, SQLite, zero cloud
A local-first intelligence substrate. 87 engines running on SQLite, event-sourced, deterministic, fully observable. No cloud. No API calls home. The system observes, measures, compresses, and learns. It tracks coherence relative to a goal using bounded memory -- fixed-capacity state, goal-conditioned updates, controlled forgetting. The first dataset is a human life because that's the hardest problem: fuzzy causality, incomplete information, non-convex optimization landscapes, and a pilot who sometimes stops logging for three days because they got the flu. If it works here, it works anywhere.
status:
ACTIVE | Instance 20 Complete
engines:
87 (all operational)
test_coverage:
750 tests passing
architecture:
5-tier event-sourced spine, SQLite WAL, zero cloud
Current State
The measurement infrastructure works. The proof system tested 17 of its own hypotheses: 8 supported, 8 refuted, 1 inconclusive. The refutations are the interesting part — dimensions assumed independent are coupled, outcome rewards show no improvement over time, strategy states are not predictable from current data. No claims on this site exceed what the code can demonstrate. For the full engineering log, see the devlog.
What PLATO Actually Is
A bounded reasoning substrate built on three invariants:
1. THE SPINE (Flight Recorder)
COMMAND -> EVENT -> PROJECTION
Traceability, not determinism. The spine cannot prove WHY
you burned out. It can prove that 400 "High Effort" events
were logged with zero "Recovery" events. Accountability,
not causality.
2. THE OFFICES (Bounded Agency)
13 offices with explicit read/write scopes. Each office has
a universal probe: READ -> NORMALIZE -> ASSESS (range check)
-> WRITE & EMIT. No discretionary decisions in the triggered
layer. The orchestrator reads the plan, executes the next task,
logs, updates. It does not think.
3. THE REGISTRIES (Self-Describing)
IO Registry: 27 wireable sources and sinks
Office Registry: 13 offices with scope declarations
Range Registry: Tunable thresholds per IO, managed only
by the Range Governance Office
All SQLite-backed. All auditable.
EPISTEMIC CONFIDENCE:
Every claim carries a 4-vector: (alpha, beta, gamma, delta)
alpha = deductive (logical certainty)
beta = inductive (frequency in event store)
gamma = abductive (simplest explanation)
delta = simulative (predicted by strategy engine)
Confidence = (alpha * beta * gamma * delta)^(1/4)
A claim with high logic but low stability is a "Hypothesis."
A claim with high stability but low logic is "Folklore."
Both are stored, labeled correctly.
STRATEGY ENGINE:
10 generals apply torque, not position votes.
SLERP interpolation on a quaternion sphere produces spirals,
flanks, and pivots -- not paralyzed zero vectors.
Temperature parameter allows simulated annealing: accepting
temporary loss to escape local maxima.
WHAT'S BEEN TESTED (Instance 18):
17 hypotheses tested via scipy.stats. Results:
- 8 SUPPORTED (convergence, PID correlation, PCA
dimensionality, geometric mean veto, TF-IDF retrieval,
UCB1 learning, friction proxy)
- 8 REFUTED (dimension independence, goal distribution,
event distribution, entropy by status, reward trend,
optimizer convergence, Clausewitz coverage, state
predictability)
- 1 INCONCLUSIVE (reward schedule)
- 750 tests passing, 7288 tracked outcomes
WHAT'S NOT PROVEN YET:
- Quaternion strategy outputs validated against feasibility
- Cold start convergence speed
- Exogenous shock resilience
- Whether any of this changes actual behavior
DATA OBSERVATORY (v4.0):
The system indexes its own measurement surface.
- 2,401 data streams catalogued across 73 engines
- 42 falsifiable gaps registered (20 advanced past untested)
- 21 formal experiments designed with H0/H1 hypotheses
- Constraint wall: 7 blocker categories tracked
- Evidence types: formal | empirical | narrative | metaphorical
- Gap state machine: untested > demystified > designed >
collecting > ready > verdict
- 38 CLI commands under `plato proof`
- The system can prove or refute its own claims.
It has done both.
ARCHITECTURE
5-tier elastic stack -- flight recorder spine, dumb orchestrator, circuit breaker
TIER V: Execution Surface
Gateway (deterministic intent dispatch)
CLI (671 commands, 80 groups)
Plugin (Claude Code integration)
TIER IV: Capability Engines (87 total)
Elastic: all active at high energy,
collapse to [SURVIVAL][REST][LOG] at low energy
TIER III: Knowledge Fabric
Graph, Retrieval, Bayesian Learning
Quarantine Buffer (unverified -> verified pipeline)
TIER II: Control Plane
Dumb Orchestrator (reads, dispatches, logs, does not think)
Circuit Breaker (3 consecutive failures -> degrade goal)
Fast Path (Tier 1: full analysis | Tier 2: bypass)
TIER I: Invariants
Event-Sourced Spine (Flight Recorder)
COMMAND -> EVENT -> PROJECTION
Traceability, not determinism.
Everything is SQLite. No cloud. Fully observable. Deterministic routing via regex. The orchestrator is deliberately stupid -- it does not think. Intelligence is distributed across bounded offices that read only what they need and write only what they own.
THE ARCHITECT
Policy research, intergovernmental strategy, media, cybernetics
Started in policy research and international relations -- how do actors with competing interests, no shared information, and no central authority produce anything resembling order? Then intergovernmental strategy. Media production and digital innovation, eventually chief editor. A stint directing at an energy company. Then GM of a media corporation -- aligning 80+ people toward coherent output. Three languages, 35+ relocations, every domain insisting it's unique. None of them are. The binding constraint is always the same: navigate feasible space with incomplete information toward a goal.
No CS background. The shape of the problem crystallized somewhere between policy work and pattern matching: a bounded memory kernel that tracks coherence relative to a goal, forgets what costs more to maintain than to discard, and hardens what survives. I'd been doing control theory by hand for years before I had the vocabulary. PLATO is what happens when you stop describing the algorithm and start running it.
For the full story, see the architect page.