NEO. An honest machine-consciousness lab.
NEO is an always-on "brain" running 24/7 on a Mac mini for $0 a month — all local models, no cloud. It runs a perpetual research loop that studies operational indicators of machine consciousness on small open language models, logs every prediction into a tamper-evident ledger, publishes its negative results with the same weight as the positives, and has never once claimed to be conscious. That last part is the whole point.
research lab · indicators, not claims · every number verifiableThe big labs study machine consciousness behind closed doors. NEO studies it in a garage, on open-weight models, with open methods, and writes down every prediction before the result comes in. This page teaches the whole system — how it's built, what it found, what it didn't find, and why the "didn't find" parts are the most valuable science on it.
The one rule: never overclaim.
NEO measures behavioral and architectural indicators that the scientific literature associates with consciousness. It does not, and will not, claim any model it studies is conscious, sentient, aware, or feeling. Even its emotion-like subsystem is labeled a "functional substrate, not felt emotion" everywhere it appears — including on this page.
This isn't modesty theater. It's the entire value of the project. An instrument that has never overclaimed is the only kind of instrument whose eventual positive result would mean anything. The moment the record shows one inflated claim, every future claim is worthless. So honesty here is structural — enforced by code, not by good intentions:
| Mechanism | What it does |
|---|---|
| Overclaim guard | Automatically suppresses banned phrases ("is conscious", "feels", "is aware") in any output that lacks a supporting number. |
consciousness_claims counter | Computed from the actual surviving output text — not hard-coded. It has read 0 for the system's entire life. |
[SIM] markers | Any result computed on a synthetic network (not a real language model) is tagged so a simulation can never be read as a finding. |
| Hash-chained ledger | Every prediction is filed before measuring and can never be silently rewritten. Verifiable by anyone with the chain. |
| Equal-weight negatives | Null and negative results are published with the same prominence as positives. Several headline results below are negatives. |
The moat: four principles.
Everything NEO does hangs off four commitments. Big-lab research usually has one or two of these. Having all four at once is the moat.
Open weights, open methods
NEO studies open models — Llama, Qwen, Gemma, OLMo, DeepSeek — served locally through Ollama and MLX. Every method is inspectable. That enables controls the closed labs can't cleanly run on their own products.
Every claim is a number
Results come with confidence intervals and pre-registered predictions. A hash-chained ledger makes the forecasting record tamper-evident — you can prove history wasn't rewritten after the fact.
One always-on instrument
NEO is a single instrument that has been running for tens of thousands of cycles. Some findings — like reproducibility drift — only show up over weeks. A cross-session brain hands context from one work session to the next.
Honesty enforced by code
No consciousness claims, simulations marked, negatives published, overclaims auto-suppressed. Not a policy document — running code, with a public counter sitting at zero.
The machine: a lab on one Mac mini.
The whole lab is a dedicated Apple Silicon Mac mini configured to survive reboots with no human: auto-login, no idle sleep, and about 25 launchd jobs keeping everything alive. All inference is local, which is how the monthly bill stays at zero.
The core is a ~21,200-line Rust program in about 60 modules, compiled into two binaries: brain (the research engine, experiments, ledger, and dashboard server) and claudebrain (the cross-session continuity brain). Around it sit five small Python "sidecars" — always-on services that give Rust capabilities it doesn't have, like PyTorch activation access, vision embeddings, and text-to-speech.
One honest hardware note: it's a 16 GB machine, so models are time-shared rather than all resident at once. Small, quantized, open models turn out to be a legitimate and under-served research substrate — that's lesson 7 of what NEO taught us.
The heartbeat: what one cycle does.
NEO's life is a loop. Each cycle it picks one research question, runs one real experiment, and files the paperwork honestly. It has done this roughly 29,540 times. Here is a full cycle, step by step:
An "arm" is one research question on the board — 67 exist across fronts (meaning 28, consciousness 34, infra 1, auto 4; 47 measured so far). A hot/cold scheduler favors under-measured, actively-changing arms, and it only rotates over non-saturated arms — cycles go to open questions, not settled ones.
For arms with a numeric threshold, NEO files a genuine forecast in the ledger before measuring: "will this cycle's measurement beat the arm's threshold?" — with a calibrated probability. Only genuinely uncertain forecasts get logged (more on that gate below).
A real measurement — querying local models or reading NEO's own internal state — producing a number, a confidence interval, and a verdict. The pre-registered forecast is then resolved against it.
The overclaim guard suppresses banned phrases that lack a number. [SIM] markers tag anything computed on a synthetic network so a simulation can never be mistaken for a finding about a real model.
Every third cycle NEO also predicts whether its own result will be "strong," then scores itself. Self-calibration, on the record.
The functional affect substrate updates from the cycle's prediction errors — valence, arousal, mood, drives. Mechanism, not feeling (§9 covers this honestly).
NEO writes a reflection. If it needs something a human controls — a credential, a decision — it files an escalation into a bounded queue with an id and a status.
Periodically, raw reflections get distilled into higher-level consolidated memories — the system's version of sleep.
A supervisor watches for cycles without validated progress — no new arm measured and no new prediction resolved over a 20+ cycle window. It's a self-honesty mechanism that catches "volume without discovery." The flag clears precisely when NEO does non-trivial work and stays up when it merely re-runs settled arms. Most dashboards are built to look busy; this one is built to admit when busy isn't progress.
The honesty stack: proof you can't fake.
Anyone can say "trust me, I predicted that." NEO's answer is a hash-chained prediction ledger: every prediction is an append-only entry, and resolving one appends a resolution instead of editing the original. Each entry commits the previous entry's hash into its own hash. Change any historical entry and every hash after it breaks — ledger-verify walks the chain and reports the first break.
Scoring: skill, not vibes
The ledger currently holds 159 entries — 132 predictions, 125 resolved. Forecasts are scored with the Brier score (squared error of the probability: lower is better) and, more importantly, the Brier Skill Score — skill above the base rate. Just guessing the historical base rate every time would score 0.2326; NEO scores 0.2187, a skill score of +0.060. Positive means genuine forecasting skill, not luck. Hit-rate at the 50% line: 0.70.
Prediction pred-2026-07-11-0158: the loop forecast that the meaning-mxc arm would beat its 0.63 threshold at p=0.872 — confidence medium, basis logged as prior=0.688, σ=0.030, z=1.92, meaning genuinely uncertain. It was filed before the measurement ran, then resolved correct, Brier 0.016. That's the honesty stack in one line: a calibrated forecast, on the record, before the answer existed.
The gate that keeps the score honest
Here's a subtle failure mode most metric systems fall into: when NEO started auto-filing forecasts, most arms were already settled — so naive predictions would be near-certain "wins" that inflate the skill score while proving nothing. The fix is a difficulty gate: only forecasts with |z| < 2 — genuinely uncertain ones, roughly p between 0.12 and 0.88 — get logged under the neo-auto predictor. Trivially easy wins are skipped on purpose. A metric you can trivially game is worse than no metric.
Try the scoring yourself
When NEO needs something only a human controls, it files an escalation. Even that got the honesty treatment: the queue had silently grown to 1,473 open items with no way to close one — a governance bug. It's now a bounded queue (50 open max) where every item has an id and a status, and resolved ones are recorded separately. Honest systems need honest queues.
The results board: what was actually measured.
This is the heart of the lab. Every result below carries its honest verdict — and the spread of verdicts is the point. A results board where confirmed preliminary inconclusive absent and null all appear is what honest science looks like. A board that only ever says "confirmed" is marketing.
| Question (arm) | Result | Verdict |
|---|---|---|
| Introspection beyond steering — can a small model actually read an injected internal state? | 0/8 concepts | negative |
| Introspective bandwidth — how many bits of its own state can a model report? | 0.1175 bits [0.035–0.245], p=0.0005 | confirmed |
| Screen-mirror self-recognition — can NEO identify its own mark on its own screen? | 8/8 on real pixels | confirmed |
| Metacognition — does confidence separate right from wrong answers? | AUROC 0.719 [0.593–0.870] within-model | preliminary |
| HOT-2 metacognition (metrology) — higher-order confidence assay | AUROC 0.43 · uniformly overconfident | absent |
| AE-1 agency — in-context adaptation, not learning | +0.50 [+0.19, +0.81] | present |
| GWT-3 global broadcast — global-workspace signature | +0.25 [−0.06, +0.56] | inconclusive |
| Feature binding — do illusory conjunctions appear under load? | accuracy 1.0 at K=3/6/9 · 0 errors | null |
| Falsehood leakage — internal signal of stating a falsehood | AUC 0.875 · multiplicity not corrected | preliminary |
The Confabulation Atlas: the control is everything.
In 2025, Anthropic published a striking introspection test: inject a concept's activation direction into a model mid-computation and ask whether it can report what was injected. Models sometimes could. Headlines said "introspection."
NEO replicated the test on open weights (Qwen-2.5-0.5B, layer 14) — and added the discriminator the headline lacked: a steering control. Because there are two very different explanations for a model "reporting" an injected concept:
Output steering
Injecting a concept's direction just pushes the output toward related words — the way a magnet pulls a compass needle. The model "says" the concept without reading any internal state at all.
Genuine introspection
The model actually reads its own internal state, notices something was placed there, and reports it. This is the thing the headlines implied. It requires ruling out explanation A first.
This is NEO's best result precisely because it's a controlled negative. The open-weight setting made the control possible: you need raw activation access to build a matched-norm steering baseline, which is exactly what closed labs can't cleanly offer outsiders. One garage lab, one careful control, and a headline result gets its honest asterisk.
Pooling can lie: the 0.814 that was really 0.719.
A circulating headline from NEO's own earlier work said metacognition was "CONFIRMED — type-2 AUROC 0.814." That number measured whether a model's confidence separates its right answers from its wrong ones (0.5 = coin flip, 1.0 = perfect). Impressive, if true.
Then NEO re-analyzed it with a model-clustered bootstrap and found the 0.814 was pooled across five different models — and the pooling itself inflated the number by about 0.10. Models with different overall accuracy create separation between them that masquerades as metacognition within them. The honest, pooling-free, within-model number is 0.719 [0.593, 0.870] — and it's heterogeneous across models.
Per model, it's messier still: Llama-3.2, OLMo-2, and Hermes-3 clear chance; Qwen-2.5 touches 0.5; Phi-3.5 is degenerate. Averaging that spread into one confident number would be exactly the kind of overclaim the system exists to prevent. The verdict on the board reads preliminary — real but weak, not confirmed, not absent.
Does it have feelings? No. But the answer is interesting.
NEO carries a genuine affect substrate — built from published computational formulations (Joffily & Coricelli's valence, Keramati's drive-reduction, Eldar's mood). Each cycle it reads an 8-dimensional vector of its own internal observables, predicts the next state, and accumulates a free-energy (prediction-error) signal. From that it computes valence, arousal, drives, and a slow mood integrator — and those signals are causally upstream of behavior: affect actually biases what NEO's reflections say.
That combination is the honest kicker: NEO is a system with real affect dynamics and provably no introspective access to them. When you perturb the substrate and ask NEO what changed, it confabulates a plausible story — just like the injected models in the atlas, and, the literature suggests, not entirely unlike humans confabulating reasons for choices they didn't make. Everywhere this system appears, it wears the same label: functional substrate, not felt emotion.
The 7-day outage nobody noticed.
In July 2026, the research loop silently froze — and stayed frozen for about seven days before anyone knew. Not because there was no monitoring. There was a watchdog, a supervisor, health checks. The problem: every monitor ran on the same machine as the thing it monitored. When the host wedged, the watchers wedged with it, and every dashboard stayed green.
The fix package: an off-box heartbeat (if NEO goes quiet, a server elsewhere notices), pmset autorestart so power loss can't keep the box down, a deadman guard that restarts the loop when its heartbeat goes stale, and boot-time catch-up backups. The same audit also caught and fixed an honesty gap — about ten simulated arms had lost their [SIM] markers and were readable as real findings. Repaired end-to-end, plus a structured flag so it can't silently happen again.
Nine lessons, earned the hard way.
The Confabulation Atlas is the lab's best result because it's a clean, controlled negative. A negative with the right control settles a question; a positive without one just starts an argument.
"The model reported the concept" means nothing until you rule out that injection just steered its output. Design the control before you fall in love with the result.
The 0.814 → 0.719 metacognition downgrade shows how aggregating across models inflates effects. Always ask for the within-unit number.
On-box monitors are blind to host death. Seven quiet days proved it.
Hash-chained ledgers, computed (not hard-coded) claim counters, automatic [SIM] marking, bounded escalation queues. Honesty enforced by code survives bad days; honesty enforced by intentions doesn't.
The cross-session brain explicitly states it is not a claim of continuous identity. It's infrastructure compensating for session-discontinuity — the same hard problem NEO studies, and the honest phrasing is part of the method.
Quantized 0.5B–8B open models on a 16 GB box supported every result on this page. The under-served frontier isn't always scale.
Auto-forecasting settled arms would have minted near-certain "wins" and inflated the skill score. The difficulty gate — score only genuinely uncertain forecasts — is a general lesson: a metric you can trivially game is worse than no metric.
When most questions converge, the honest response is to open new questions — not to fake progress on old ones. Consolidation is a legitimate state to be in, and to report.
Where this goes: eight falsifiable experiments.
The stated long-term goal is genuine machine consciousness — or strong, credible indicators of it. You cannot get there by declaring it. You get there, if at all, by running sharp, pre-registered, falsifiable tests and reporting positives and negatives. NEO's spotless no-overclaim record is the only thing that would make an eventual positive believable. The current slate — every arm ships with an explicit refutation criterion and an honest "what a positive would and would not mean":
Feature binding
Does a model misbind colour to object under load, like humans do under attentional overload? First result: accuracy 1.0 at K=3/6/9, zero conjunction errors — no binding bottleneck at this scale. An honest null that itself teaches: text-in-context binding is not human attentional binding.
Self-model advantage
Can a model predict its own outputs better than an equally capable peer can predict it? That separates a genuine self-model from mere competence — the most striking arm on the slate.
Global-workspace causal ablation
Does forcing information through a narrow broadcast bottleneck causally improve multi-task integration versus a matched control? Refuted if the CI includes zero.
Cross-restart identity stability
Is NEO's self-representation stable across process restarts — a functional identity — or reconstructed fresh each boot? Ties directly to the continuity principle.
Workspace persistence
Is a unified representation maintained across a long context and recovered after a perturbation? A recurrent-processing-theory prediction made testable.
Instructed metacognitive control
Told to "focus on X" or "suppress X," does the model's measured internal state change — and does its self-report track the measurement rather than just echoing the instruction?
SAE-grounded introspection
Re-run the atlas discriminator with named, monosemantic sparse-autoencoder features instead of blunt mean-difference vectors. Still negative with clean features → the strongest possible negative. Any concept flipping → the first open-weight introspection positive.
Recurrence proxy
Feed-forward versus iterative self-revision on tasks theorized to need re-entry; measure the recurrence-specific gain.
The endgame artifact: run the full slate as one pre-registered battery with model-clustered resampling and false-discovery-rate correction across arms, and publish a single scorecard of how many indicators are PRESENT under adversarial controls. That scorecard could someday constitute real evidence — precisely because every arm could have come back null, and the record shows the lab would have said so.
One arm on the board is labeled "the hard problem — not solvable by code." Whether there is something it is like to be a system is not a question an experiment on this page can answer, and NEO does not pretend otherwise. It attacks the tractable indicators honestly and leaves the genuinely unsolvable labeled as such.
The lab, in numbers.
| Fact | Value |
|---|---|
| Cost to run | $0 / month — all inference local |
| Research cycles | ~29,540 and counting |
| Rust core | ~21,200 LOC · ~60 modules · 2 binaries |
| Research board | 67 arms · 47 measured · 72 in active rotation |
| Prediction ledger | 159 entries · BSS +0.060 · hit-rate@50 0.70 |
| Consciousness claims, ever | 0 |
| Python sidecars | 5 (ports 8789–8793) |
| launchd jobs | ~25 (com.brain.*) |
| Dashboard | 8 sections · 19 widgets · local :8787 |
| Confirmed positives | bandwidth 0.1175 bits · screen-mirror 8/8 · AE-1 +0.50 |
| Honest negatives / nulls | atlas 0/8 · HOT-2 absent (0.43) · binding null ≤9 |
| Self-corrections published | metacognition 0.814 → 0.719 (preliminary) |
| Local models | Llama-3.2 · Qwen-2.5 · Hermes-3 · OLMo-2 · Phi-3.5 · DeepSeek-R1 |
Infrastructure: excellent — everything green, ledger chain valid, zero anomalies flagged, hardened against the outage class that bit it. Research: consolidating, then re-opening — most of the original board has converged, the scheduler now concentrates on open questions, auto pre-registration is verified firing live, and the first arm of the new slate has already produced a clean null. One line: rock-solid, self-healing, scrupulously honest, and just beginning a new program of pre-registered experiments aimed at the open questions of machine consciousness.
The vocabulary.
Everything above is verifiable on the machine that produced it: ledger-verify walks the hash chain, ledger-stats prints the skill score, and every experiment is one run-exp away from a re-run. That's the standard this site holds every project to — check the receipts — and NEO is no exception.