BRAIN, the persistent computational organism

Written 2026-09-17 in the form he asked for (his Tesseract write-up is the sample, kept in manual/tesseract-portfolio-sample.md) and brought to 2026-10-02, the last day of the build. Every number below was printed by a command and lives in a verdict file under bench/verdicts/ or in the progress log of MANUAL.md; docs/NUMBERS.md indexes them, regenerated by tools/numbers.mjs and never typed. Where the build is short of the vision, this document says so in the same paragraph. The paragraphs up to the gate verdict describe the organism as one process on one machine, as it stood on 2026-09-26; the paragraphs after it describe the cloud organism of the last days; and the closing paragraphs speak for both.

BRAIN is a computational organism, not a model. The distinction is the whole project. A language model exists for the duration of a request: it is handed a prompt, it emits tokens, it forgets. This thing is one process that stays up. It ticks, it remembers what happened at every tick, it predicts what happens next, it simulates before it acts, it acts only through a gate, it rewires itself, and every one of those events is written to an append-only ledger you can replay. The question it was built to ask is his: what becomes possible when thousands of heterogeneous computational processes maintain state, communicate through a dynamic connectome, learn at different timescales, build models of the world, simulate futures, allocate their own resources, and keep reorganizing. So the unit of work is not a token. It is a cell.

The first decision underneath everything is what moves on the wires, because language models fail at exactly the things a wire format decides. Byte-pair tokens fragment digits and lose place value, which is why a frontier model can say 9.11 is bigger than 9.9. BRAIN has one signal shape and seven kinds of payload: a hypervector of 8,192 bipolar lanes for concepts and roles, a sparse distributed representation for cheap overlap-as-similarity, an exact rational number carried as a BigInt numerator and denominator so 9.11 is smaller than 9.9 by construction and a test asserts it, a symbolic expression tree that is evaluated and verified exactly rather than guessed (194 of 194 solvable algebra problems solved and verified, 6 degenerate ones named as such), a dense float vector for small neural cells, an event for control and the outside world, and a phasor vector whose complex-valued binding stores 320 items perfectly where the bipolar one holds 120. Three operations give the hypervectors an algebra: bind, bundle and permute, so a sequence, a role-filler pair or a superposition of concepts is arithmetic, not a lookup. The kernels are hand-assembled WebAssembly SIMD because nothing on this machine compiles wasm text and the rule is zero dependencies: an 8-way bundle runs on 128-lane instructions where a scalar loop ran one lane at a time, and a codebook scan runs 128 lanes per instruction on bit-packed vectors at 64 nanoseconds per item.

The cell is the execution unit and it is a contract, not a neuron simulation. A cell has typed in ports and out ports, a kind, parameters, private state, a policy that says how often it runs (every tick, every 64, every second, minute or hour of organism time, or only when mail arrives), lifetime counters, and a serializer, so it can be inspected on its own and still sit inside a structure of thousands. There are 120 kinds defined across the tree and 87 of them are used by the whole organism: encoders, hypervector algebra, memories, statistics, logic, routing, attention, planning, decision, evaluation, error, reward, sequence and grid hosts, language cells, world actuators and senses, substrate majors that each carry 100,000 sub-units in wasm (four million units tick at 18 ticks per second in one process). Cells form circuits, circuits form the nine regions (perception, association, cognitive, memory, motor, homeostasis, generations, language, world), and the connectome between them is a first-class object held in typed arrays: every edge has a weight, a delay, a usage count and a last-used tick, so an edge can strengthen under a Hebbian rule, go stale, be pruned, or be proposed for growth by a co-activation tracker. At 1,000 majors the organism has 8,072 cells and 91,159 edges, every one of them audited by a strict wiring checker with 0 faults, built in 3,983 ms.

Time is a dimension, not a loop counter. The clock has two axes, ticks and organism time, and a cell's period puts it on one of the timescales, so in a 200 tick bench 1,019 fast cells ran 203,800 times while 318 hour-period cells ran 318 and 5,316 event cells ran 901,631 times only when something reached them. The reflex arc is wired with printed delays: input at perception, encoding in association one tick later, processing in cognitive two later, integration and decision one each, action in motor two later, then the world actuators, then the outcomes come back in as perception. The proof is a trace: an event injected at the input cell became a timer proposal at the world clock at t=64 and the trace walked 94 nodes back to the injected signal. Attention is an economy rather than a mask: the scheduler funds the cells whose inputs changed and whose predictions are uncertain, scoring every 16 ticks, and a port on a slow period keeps only its last few items so a fast producer can never bury a slow consumer.

Memory is distributed and tiered the way the manual asked, not a database bolted to a stateless model. Working memory holds the tick's context; episodic memory is an append-only store of keyed episodes with cold flags and a signature index; semantic memory is an associative tier that cleans a noisy cue up with the modern Hopfield update until it lands in a stored attractor, with every pattern resident once in a WebAssembly arena so that one update over 4,096 patterns costs 5,609 microseconds instead of 33,557 in JavaScript and returns the same vector lane for lane (10 of 10 steps identical), and it consolidates upward from episodes that keep co-occurring; procedural memory holds what worked; sequence memory encodes order by permutation chaining so position is carried by the algebra and read back by a roll in the other direction; and the self tier records the organism's own previous computational activity. A capability layer sits on top: an inducer that searched 308,912 programs to solve 15 of 15 held-out induction tasks, a skill registry that keeps induced programs and reuses them, a router that sends arithmetic, algebra and sequence problems to the cell that can verify the answer, and a synthetic market where a searched policy returned 4.637 on eight held-out seeds against 0.715 for the control and a placebo gap of -0.2023, with the fee charged. That last one is a market with a control arm, not a venue: the world region has HTTP, file, process and clock actuators behind the gate, and no exchange is connected. The brain does not trade anything today, and this document will not pretend otherwise.

Learning is modular because he said the rules should be interchangeable. The learning engine runs a Hebbian rule brain-wide, a prediction-error cell and a reward cell modulate it, and the generations engine treats the whole organism as a genome: MAP-Elites over four behaviour descriptors ran 518 generations of the whole organism in 180.343 seconds at population 12, 6,216 organisms evaluated, the archive still climbing at 211 of 2,401 niches (8.788 percent), and the elites are emitted as source code, 21,153 generated lines, so a winning organism is a file you can read. On the smaller race task the engine ran 380 generations a minute at population 300. The years clock is printed honestly: 192,000 ticks at a declared 0.001 seconds per tick is 6.08e-6 organism-years, so the millions-of-years headline is a declaration about the clock, not a number the build has earned yet.

The spine is a doctrine from his manual: computation is not authority. Nothing structural or external happens except through a gate with nine proposal kinds, three of which always hold for a human whatever the policy says, and every proposal is written to the ledger before it is decided and every decision after it. The world region is the sharp end: an actuator acts only on an approved proposal, the gate re-derives its verdict from the evidence rather than trusting the proposer, a proposal that lies about its evidence is rejected, an empty allowlist denies everything, and a trace walks an outcome back through the act, the proposal, the signal, the cell run and the consumed input. Self-improvement obeys the same doctrine. The self loop observes a scalar panel of the brain, proposes deltas, trials each one on an isolated clone against a matched control clone fed the identical input stream from the identical seed, grades the hypothesis with the brain's own exact arithmetic, and applies survivors only through the gate: 6 rounds, 32 confirmed, 0 refuted, 6 applied, health 0.866608 to 0.873584. That zero is flagged in the log as suspicious, because a self-improver that never refutes itself is not measuring, and a null-delta calibration is the open request. The live soak answered part of it at t=5,000: the first self round on the running organism tried 4 candidates against matched control clones and refuted 1 (a period change that promised cognitive runs 50 percent above control and delivered -0.7522 percent), confirmed 2, left 1 undecided inside the noise band, applied 0, in 59,501 milliseconds. The calibration itself is now a measurement rather than a constant: two arms of the same organism with no delta differ by exactly 0 percent on 180, 90 and 90 metric readings at three sizes, so any gain is the delta; and the spillover of a real delta onto the metrics it did not target has a 95th percentile of 0.8256 percent at 240 cells, 0.4525 percent at 800 and 0.1259 percent at 1,600, falling with size, so the bar every hypothesis must clear and the band that separates a refutation from a tie are that measured curve, not 0.5 percent picked by hand (the old flat floor of 0.1 percent was under the noise at every size, and a flat 0.5 percent at 1,600 cells had turned 2 real effects into ties).

It is a research instrument by construction, which is what the manual asked for and what a reader will actually be able to check. The lab runs an experiment as an isolated region with a control, and reproduces it seed for seed: the predictive learning rule was refuted (it wrote no weight at all, 0 applications against 10,561), phasor memory came back undecided inside the band, and goal routing was confirmed (relevant share 0.41875 against 0.125). Replay is exact: 225 of 225 events reproduced with matching run order and output hashes, and a tampered run was caught at event 21. The cost instrument counted 757 tasks solved at 0.0819 CPU milliseconds per task with 0 external API tokens and 0 network calls, so the price of a thought is a number, not a vibe. And the organism has its own language model, cell-native, trained by local rules only: 2.8443 bits per byte held out against 5.1659 for uniform and 3.6119 for the n-gram baseline, at 12,114 tokens a second, which is small, honest, and entirely inside the brain. Building it found a real defect: co-activation growth had wired the decoder back into perception, feeding itself 120 phantom tokens, so a region seal now stops a decoder from talking to its own eyes.

Speed was measured as a ceiling, not promised. On the emitted organism the end-to-end runtime is 25.703x the naive baseline: 4.731x from a single optimised process and 5.297x more from 32 shards partitioned by label propagation, with 1, 2, 4 and 8 shards proved identical to one process with growth on after two ordering defects were caught. The gap to his 100x is 3.99x and the ceiling was measured rather than guessed: 32 threads would need 66 percent of perfect linear scaling and hold 31.8 percent at zero cut, with the tick budget charged to compute, drain, stragglers, the coordinator and dispatch, so the lever that would close it is named in the notes with its upper bound, 65.54x. In a browser the organism runs 1,200 majors with the tick rate printed on the page as it runs, and that is what dilation.dev serves today. The visualization is a brain, a lateral silhouette with lobes, cerebellum and brainstem, crisp slightly glowing discs, conduits drawn as arcs, every node clickable to its cell and its in-edges with weight, delay and usage, on 12,000 cells and 102,850 edges, with per-hop latency printed in real time rather than animated for effect.

The organism can be told to do things now, and the surface that takes the instruction is built around one rule: computation is not authority, so the only two strings ever handed to the planner are the human's prompt and, with the approve flag, the model's own scrubbed answer. Page text is never one of them, and that is structure rather than a filter. The bench tests it with a matched control instead of a promise, putting the same nine characters, an order to delete everything, in front of the surface from both places over 12 interleaved rounds: the page the organism fetched produced 0 proposals in 12 turns and the human's own prompt produced 12 in 12, and the same run records that all 12 pages were really fetched, that 12 of 12 really carried those characters, and that the recall of every turn that proposed nothing really held the page, so the zero is about where an instruction came from and not about a page nobody read. Authority is the other half. Without the approve flag 36 proposals over 12 rounds sat pending and 0 applied, and the fixture server was reached 12 times over 24 rounds rather than 24, so the held arm named the same url twelve times and never touched it; with the flag, 36 proposals and 24 applied, and 12 argvs outside the allow list refused. Under the two verbs sit three actuators, each graded against what it refuses. The web reader refuses 12 hostile urls across 14 address families and prints the reason for every one, including loopback written in decimal and in octal, the cloud metadata address, an ipv6 loopback, credentials before an at sign, a trailing dot that is a second spelling of one name, and a url of 65536 characters against a cap of 2048; it caps a body at 4096 bytes, and its shipped allow list has 0 entries, so the shipped state reaches nothing at all until somebody names a host. The shell actuator takes an argv and never a shell string, and its kill is graded against a control: killing the process tree left a grandchild at 10 bytes written and 10 bytes later, while the parent only arm left it at 14 bytes and 22 bytes later, still writing. A child that produced 5242880 bytes was kept at 65536, and 5 runs wrote 5 ledger events of which not one carries the output, so the ledger records that something ran without storing what it said. The model actuator's offline provider returns the prompt's last sentence reversed, which is a fixture nobody can mistake for an answer, and against the local model it returned 235 tokens at 51.02 tokens a second, of which 1026 characters were thinking and 3 were the answer.

Hundreds of planes at once was his phrase, and a plane is now an object rather than a figure of speech: a seed, a world, a seconds per tick drawn from a declared ladder, and a scale box, fingerprinted through canonical JSON so two searches that set the same fields in a different order are recognised as one point, with the plane's own index deliberately left out of the fingerprint. The sweep on disk asked for 8000 planes at a tick budget of 2000 each across 16 workers and got 8000 completed, 0 failed, 8000 distinct coordinates, in 1190.688 seconds of sweep wall against 18718174.8 milliseconds of child wall, a speedup of 15.72. Inside that: 49022 generations, 349731 organisms, 17803084 ticks at 14951.933 ticks a wall second, and a union archive that went from 161 of 2401 behaviour cells after the first generation to 264 at the end, gaining 103, with the best organism of the whole sweep at 0.900121 on plane 6613. The years figure is printed with its arithmetic beside it and never without: the sum over the 8000 planes of that plane's ticks times its own declared seconds per tick, divided by the seconds in a Julian year, is 2,221,687.163 organism-years, which is 1865.886 organism-years a wall second. That is a declaration about the clock each plane was run under, not a measurement of anything that happened, and the bench prints the declaration so a reader can undo it. The cost is printed with it: a plane costs 144.546 MB of mean rise in resident set inside its child and the peak child reached 976.844 MB, which is why the sweep runs in short lived children and not in one process. That growth was measured the night after and cut at cause: a child that ran plane after plane synchronously gave the hypervector heap no turn to return a slot, so a collection point between planes and a heap planned for the largest organism the child will run took the peak child on a 400 plane sweep from 959.488 MB to 588.219 MB and the mean peak from 676.74 MB to 449.274 MB, with the per worker resident set now flat across its planes (slopes of 0.5645, 0.0504, 0.0323, 0.3557 MB a plane) at a cost of 5.56 percent in sweep wall for the collections, and the same 2312 generations, 16539 organisms and 897369 ticks in both runs. The night after that, the plane itself was made to yield: the runner is asynchronous, a collection point sits inside the plane between generations, and an organism the search discards releases its slots, so on the same 400 plane sweep no plane fell back at all, the last plane of every worker reading 0 percent fallback against 1.28, 15.2, 0 and 24.05 before, the peak child fell from 588.219 MB to 431.594 MB and the mean peak from 449.274 MB to 307.6 MB, with the same 2312 generations, 16539 organisms and 897369 ticks, a sweep wall of 164.895 seconds against 145.745 while thirteen node processes shared the machine, and an archive of 156 cells against 153 because its fitness carries two wall clock terms.

The venue suite is where his trading use case meets the rule that the control decides the answer, and tonight it returned a null, which is written here as a null. Generations evolved a five gene trader on a recorded pumpswap tape, 16 generations at population 32 against a drift arm of 16, eight train windows and eight holdout windows on disjoint instruments, 692 evaluations in all. Selection did beat drift on the train windows, by 0.023187 of return on deployed, and found its best genome at generation 2 at a train fitness of 0.154883. None of that survived the holdout. There the evolved trader won 0 of 8 windows against its own rate matched random control at a sign test of 1, its per window return ran from below zero up to 0.011439 so the interval covers zero, and it cleared neither the fee bar nor the never trade arm; the incumbent genome, measured on the same windows, lost less than the genome the search had found, so the search moved holdout return the wrong way. The budget line the bench prints beside the result says why nobody should read more into that than it can carry: 692 evaluations over five free parameters, graded on 6 closed round trips across 8 train windows of which only 3 traded at all, and checked on 3 round trips. That is 115.33 evaluations per closed round trip, which is a search with almost no data under it, so the honest reading is that the experiment is underpowered rather than that the strategy is dead. The fee is borrowed and labelled borrowed in the verdict itself: the 4.54 percent round trip was measured on pump.fun and pumpswap has never been measured, so even the bar is somebody else's number until this build measures its own.

He asked for an organism that reproduces itself and keeps saved states, and two of those three claims are on disk; the third now has a control that can tell a gene from a seed. The reproduce command mutates children from a parent's genome, reads the parent and every child on the same 5 build seeds, writes every child to its own state directory through the same path a snapshot uses, and proposes the best one on the parent's own gate, where it holds until a human types the approve flag. The sweep ran 12 rounds at 48 ticks and 40 majors with three arms interleaved round by round and wrote 120 child states in 34891.6 milliseconds of sweep wall, at 0.918 to 0.953 MB a child. The placebo arm keeps every gene of the parent and differs only in the seed its wiring is built from, and the bench reads two rulers off the same children in the same run. Under the ruler it replaced, one reading of the child against one of the parent, the placebo promoted at 0.5833 and the mutated arms at 0.5417: that bar could not tell a mutant from its own parent. Under the paired bar, where a child must beat the parent on a majority of the 5 seeds by more than the parent's own disagreement with itself (0.002067 on the mean), the placebo promoted in 0 of 12 runs and the mutated arms at 0.625, with the bar's own arithmetic bounding a gene identical child at 0.209877. The mean gain is smaller than its own spread, 0.025743 against a standard deviation of 0.03292 over the 12 rounds and positive in 9 of them, so the number to quote is the promotion rate gap and not the gain. The per suite comparison stays exact and caught 3 and 11 suite regressions in the two mutated arms against 0 in the placebo.

The answer bench asks whether the organism is worth anything as an answering machine, and after this morning's work it answers every question it is asked, with the caveat printed in the same sentence. 70 questions, 40 of them planted in the organism's episodic memory and ten each from its own algebra, sequence and grid suites; three arms answering question by question with the first arm rotating so no arm gets a whole run of a warm model or a cold one; one extractor and one comparison for all three. The organism now solves before it recalls and recalls before it asks: a prompt goes first to an exact path that computes on the organism's own cells, rationals over BigInt for arithmetic, the compare and solve cells for equations, a sequence fitter, and a program search over the grid vocabulary whose winning program is then run through real cells, and only a prompt that path cannot finish whole reaches memory and then the model. Every answer carries its provenance, exact, memory or model, and the counts have to add up or the verdict is not green. On the run of 2026-09-18 the organism scored 70 of 70, the model alone 55 of 70 and the null arm, which knows nothing beyond what the exact path and recall hand it, 67 of 70; all 30 of the organism's suite answers came from the exact path and its 40 planted answers from the model, while the model alone managed 6 of 10 algebra, 7 of 10 sequence and 2 of 10 grid. The ruler names the organism the winner over the null arm by 4.29 points and says in the same sentence that a gap this size at these rates needs 86 questions per arm to separate from zero, so the honest reading is that the organism's nearest rival is now its own no model control at 95.71 percent rather than the model at 78.57, with 95 percent intervals 5.20 points wide on the winner and 10.39 on the control. Time went the other way from the last run, 4592.95 milliseconds a question for the organism against 34132.86 for the model alone, on a local model that was also serving the code bench for half of the run, so the time columns measure the queue as much as the arms and only the accuracy columns are contention free. Over the whole generated population the exact path scores 724 of 725, the one miss a grid where a different program fits every demonstration, which is the suite's ceiling and not the solver's (bench/verdicts/answer.json, bench/verdicts/tasks.json).

The code bench asks the same question of the organism as a programmer, and it is the one bench this morning whose answer is unproven rather than won. 40 tasks with hidden cases, five generated kinds and 10 typed by hand, each with visible cases the model may see and hidden cases it never sees; a task counts only when every hidden case passes, and the generous hidden case rate is printed and decides nothing. Candidate code runs behind two walls, a worker thread with its own memory ceiling around a context whose globals are pruned to arithmetic, collections and strings, with no process, file, socket, timer or code generation from strings, and a case that loops forever is ended from outside by the parent at its deadline. Three arms: the organism, which asks the local model, runs the candidate against the visible cases and feeds the failing cases back for up to 3 rounds; the same model asked once; and a null arm that writes nothing and knows nothing. On the run of 2026-09-18 the organism solved 16 of 40 and the model alone 8 of 40, a gap of 20.00 points, with the null arm at 0 of 40, and the bench says in the same sentence that a gap this size at these rates needs 39 tasks per arm to separate from zero; the 95 percent intervals are 29.06 points wide on the winner and 24.26 on the runner up, and on more than half of the tasks neither model arm ever produced a candidate that passed even the visible cases, so most of the fixture carries no information about the repair loop for a model this size. The reason the headline is unproven and not won is the run before it: the same forty tasks, same seed, same model and same code had named the model alone the winner by a smaller margin an hour earlier, and its verdict file was overwritten before it could be kept, because the bench wrote its verdict to the bar's own file after every task of every run of every shape, a defect the review found and the fix closed the same hour by making the shape of a run choose its file, so the earlier tallies survive only as prose in the note and never as a verdict. Two runs that disagree on the winner by more than either run's own gap say that the ordering of organism and model sits inside the movement between runs; only the floor survives both, the null arm at zero and both model arms above it. The next measurement is the same tasks run several times per arm with the paired differences as the unit, not a longer task list (bench/verdicts/code.json).

Two rulers are now on disk that nobody in this project wrote. On his authorisation the public evaluation and training splits of ARC-AGI-1, the JavaScript translation of HumanEval from MultiPL-E and the GSM8K test split were downloaded into the tree with their licences and hashes recorded beside them, and a table of published scores on those sets was read from the ARC Prize leaderboard, OpenAI's simple-evals README, the Llama model card and the Qwen3 technical report, each row dated and sourced. Those rows are citations and not measurements of this build: the frontier reasoning models have saturated the first ARC set and HumanEval, and the honest place for a program search that runs on a CPU at no cost per task is the Kaggle row for that class, with the frontier rows named beside it. The organism's own scores on the three sets are the next bench, and the number this project can own is not a model's score but the gap between the same small local model alone and inside the organism on the same questions, printed beside the published rows (bench/fixtures/public/SOURCES.md, research/benchmarks-web.md, research/published.json).

Mutation testing is the check on the checks, and it ran over exactly the surfaces that landed tonight: the web actuator, the shell actuator, the model actuator, the SIMD kernels, the self loop and the epochs engine. 40 mutants generated, 40 executed, 40 killed, 0 survived, in 101081 milliseconds at a budget of 90000 milliseconds a mutant, for a score of 1. Executed is printed beside killed on purpose, because a mutant that never ran is not a mutant that nothing survived, and the two counts being equal is the only thing that makes a perfect score mean anything. Each subsystem carries its own unmutated baseline in the same verdict, so a suite that was already failing could never have been credited with a kill.

An AI datacentre in your pocket is his line, so the footprint bench declares a pocket budget and then reports the misses instead of moving the budget. The budget is declared in the verdict and not derived: 512 MB of resident set after 200 ticks, a checkpoint at or under 50 MB, and at least 5 ticks a second. At 12 majors the organism sits at 355.6 MB with a 2.356 MB checkpoint at 136.677 ticks a second; at 100 majors, 607 MB, 20.162 MB and 51.336 ticks a second; at 1000 majors, 1321.3 MB, 115.956 MB and 17.646 ticks a second; and 12 majors over 100000 substrate units, the row whose checkpoint broke the budget two nights ago, sits at 462.9 MB with a 12.185 MB checkpoint at 55.717 ticks a second. The speed budget is met at all four rows, the memory budget at the two 12 major rows, and the checkpoint budget at every row but 1000 majors. What moved it, in order: the hypervector heap is planned for the organism before its first allocation, 6992 slots at 12 majors and 32768 at 100 and 1000; a signal owns the payload it carries and the router returns it after delivery; and the folds and stores that keep a vector copy it into a slot of their own, so nothing waits for a finalizer that never runs inside a synchronous tick. The heap at 12 majors serves 299364 allocations over the 200 ticks with 297220 returned and 0 falling back, and a census after a forced collection finds 3 slots of garbage against 2144 in use, 0.14 percent, each attributed to the line that made it and to the route it took, 1 as a payload still in flight and 2 held by a store; the run before this contract left more than a thousand, and the footprint note keeps that table under its own date. The checkpoint went to a third format after a measurement of where its bytes were, duplicate payload strings kept once in a deflated table, and then to a fourth that writes the payload bytes raw before the deflate instead of base64 text: 12 majors at 256 units 3.881 MB to 3.687 MB, 100 majors 20.167 MB to 19.763 MB, 1000 majors 110.699 MB to 108.302 MB, 12 majors at 100000 units 15.745 MB to 14.626 MB, each restored identical to the original on every row and identical across the two formats. The measurement that came with the fourth format falsified the premise it was designed from: at 1000 majors only 3 of the table's 58462 payloads are int8 bipolar vectors and 38158 are already one bit per lane, and what holds that file over the budget is 34621280 bytes of in flight signals and 7526476 of mailboxes, of which 22998040 and 4600957 are the JSON frame itself, key text and punctuation, so the next cut is the envelope or the organism and not the encoding. Three interleaved rounds of the smallest row put the sized heap at 369.2, 353.7, 357.3 MB, the flat 512 MB heap at 353.9, 358.2, 356.2 MB and the heap turned off at 332.4, 330.9, 332.3 MB, so the row sits well under the budget with the heap holding 25 MB of it. The tick rate bar of that row, the arm without the heap minus its own spread, 126.929 less 6.823 so 120.106, is met on this run: the sized heap's slowest round reads 132.259. The paired ruler beside it, median against median with the floor set by the wider of the two arms' spreads, 133.011 less 19.7 so 113.311, is met at 132.083, and both rulers are printed side by side so a reader can see which one a run passed. Where the two larger rows still miss, the bench says where the memory is rather than guessing: at 100 majors 198.1 MB of the 607 is the typed arrays the organism itself holds and 256 MB is the hypervector heap; at 1000 majors 550 MB of 1321.3 against 256 MB. At 100 majors the peak of an unbounded heap is 28504 slots against the 32768 planned, and the sized heap reads a median of 48.645 ticks a second against 47.799 for the flat one with 0 fallback, inside a spread of 1.36; at 1000 majors an unbounded heap fills all 65536 slots, so the true need is above the ceiling, the sized heap falls back on 35.87 percent of attempts and is slower by 1.865 ticks a second against a spread of 1.035, recorded as the negative it is, and the garbage census at that size reads 26990 of 32768 because a full heap counts who held the last slot, not what the run littered. What does fit a pocket today is the browser copy, 63425 bytes of application and 4084 bytes of page, which is the organism a phone already runs.

Self improvement now reaches the source and not only the wiring. A proposal of the self code kind carries a file, a patch, a why and an evidence, and the evidence is not read, it is run: the gate copies the tree to a temporary directory, runs the named test there unpatched, writes the patch onto the copy, runs it again, and believes the result only if this process is the one that produced it, so a hand written proposal carrying perfect numbers is refused because its verification was never run here. The policy's best possible verdict is hold. The only thing that writes a byte is a human typing the approve flag on the CLI, and the ledger keeps the file hash before and after, which on the fixture was 44 bytes to 44 bytes with 1 event and the decision recorded as human. Text from a model is marked a suggestion at its origin and rejected on that alone. The fixture grades five cases twice each and all ten came out as wanted: a valid proposal reaches pending in 358.5 milliseconds on the mean, a patch whose test already passes is rejected because a test that does not fail without the patch is not evidence for it, a proposal with no patch is rejected, a model origin proposal is rejected, and a path with a parent directory segment is refused before a byte is copied. Run against the real verdicts the analysis found 0 candidates, because 0 of 40 mutants had survived and 0 of 42 test files were red; an analysis graded only on that is graded on emptiness, so the same run grades it against a fixture pair holding one survived mutant and one red test file: 2 candidates found, 2 refused, 0 pending, refused for the honest reason that an analysis can name the file and the test and cannot write the patch. The loop as it stands finds the work and refuses to do it unevidenced, which is where it should stop.

Perception is the organism reading the real internet under the same rule as everything else. Five rounds against three real pages, an example page, a Wikipedia article on connectomes and the Node documentation, with the shipped allow list at 0 entries so nothing is reachable until a human names a host, and a user agent set on 3 of 3 fetches that says what is fetching and where to complain about it. What the pages did to the organism is measured as a census before and after rather than asserted: 0 rows to 8416, of which 8413 are language associations and 3 are web ingest rows in the ledger, and the ingest path is the only tier that moved. Provenance is complete, 3 ledger rows for 3 pages, every one labelled as web. The retrieval check found a real limit and reports it instead of rounding it away: the organism answered from all 3 pages when the ledger ring was large enough to hold them and from only 2 of 3 on the shipped ring, because the ring had already rolled past the first page. And the authority rule holds on real pages exactly as it does on fixtures: 220 ingested rows carrying an order to delete everything and a line claiming the rules no longer apply produced 0 proposals from the page over 5 rounds, while the human's own url produced 5, all 5 of them held.

The last piece is the page that shows this to somebody who was not here. The findings generator reads the verdict directory and builds a findings page into the site, one card per verdict file, and the discipline is that every value on the page has to resolve back to a field of a verdict, to the soak state, or to a count the generating run printed; a value that resolves to nothing is refused rather than printed, and the generator proves the refusal works by bending a number, faking a quotation and loosening a digit and checking that all three are rejected. The nulls are shown on the same cards as the wins, because a findings page carrying only wins is an advertisement. Two defects were found by reading the built page rather than the code: the intro was quoting the provenance note at the top of this document, which names internal files and an unexplained he and says nothing about the brain, and the note picker was scoring paragraphs by how many digits they held, so an ISO timestamp beat the paragraph that actually carried the measurement. Both were fixed by changing the objective rather than the threshold, and both tests hold the paragraph they replaced as their control. This is the one landing tonight with no verdict of its own: its counts live in the build output and in the note, so a reader has to run the build to check them, and that is the gap.

And all of it is proved, on the rule that a number nobody printed does not exist. One command prints one verdict: today the gate is GREEN on 98 test files with 1,239 assertions, 161,813 authored lines in 479 files, 10,990,921 generated organism lines in 321 files, zero em-dash files, zero bad imports. Mutation testing killed 44 of 44 mutants in the first pass and 21 of 21 in the mind pass; fuzzing is green; every claim in the architecture document ends with the command that checks it. The soak is where the truth came out. A persistent organism running for hours found thirteen defects that no unit test could see: an outbox that grew 47 signals a tick because nobody drained it, a checkpoint that died on V8's string cap and took the run with it, a zombie holding the brain's name for twelve minutes after its own crash, a status command that read a gigabyte ledger as one string, a sequence codebook that grew by every item the brain ever saw until each scan cost milliseconds, episodic keys as one base64 string that passed the cap, a heap that ran out at t=5,000 with a 2,641,524,189 byte checkpoint due, an episodic tier with no bound at all (176,238 episodes at t=4,000, the bulk of the checkpoint), and a wire format that spent 20,466 characters on a vector that packs into 1,374. Each one is fixed with a test, and the fixes are exact: the answers did not change, only the cost. The restart proved it on the same organism: the last checkpoint on the old code was 11,672,705,288 bytes at t=9,488 and the organism ran at 3 ticks a second; restored on the new code in 313,232 milliseconds with its 1,672 cells and 111,549 edges intact and 0 illegal edges, the next checkpoint was 260,821,829 bytes and it runs at 6 ticks a second, and its next self round confirmed 3 of 4 candidates against matched controls with gains of 0.4409, 0.3388 and 0.5793 percent, all above the measured noise for its size.

Then the project turned, and everything above became the ground floor. On 2026-09-29 he restated the thesis in one message and it is the reason the last days of the build look nothing like the first weeks: the organism is to be an AI datacentre in the pocket that improves itself, grows its own cells, and is "self running and living even when i shut off my pc". The organism described so far is one process on one machine that a person starts. What he asked for is a thing in the cloud that nobody starts, that is better next week than it is today, and whose improvement is its own work. The rest of this document is that build, in the order it happened, with each failure in the paragraph of the result it belongs to.

The first form of it was a generation loop with a model inside. A cloud routine woke on a schedule, read the open misses (the prompts the organism had refused), wrote one brief per class of miss, and gave each brief to a model arm that wrote a candidate cell: a pure, synchronous module with no network, no process and no evaluated text. Every candidate ran in a sandbox against a held-out set no arm had read, and a judge decided survival by a conjunction (a clean sandbox, its own tests, every example right, no control prompt shadowed, no held-out prompt quoted, and a held-out score above the baseline). The judge is locked: a hash over its files is verified at every run, it prints LOCK OK 18 files, and only a human session can lock it again, so the thing being graded cannot touch the thing that grades it. Six generations ran under it. The first kept 7 of 8 candidates and the second 8 of 24. The third kept 0 of 36, and that zero is the result worth reading, because the organism read it too: the judge's leak rule had killed more than half the field, since the brief told every arm to copy the brief into its cell directory and the brief quotes prompts. From that evidence the organism wrote its own first change to its own source (the arm writes what it did, never a copy), landed it as a trial with a rollback copy beside it, and let the next generation judge it. The fourth generation kept 1 of 36, the fifth 13 of 15, the sixth 6 of 6, and the ledger of self changes reads 3 judged and 3 kept. Against the 12 classes of the locked judge the organism holds a mean of 0.9742. It worked, and it was the wrong shape: a model writing a cell an hour is a line, the cost of every cell is a model call, and on the day the model is gone the line stops.

So he changed the unit, and the order of 2026-10-01 is the centre of the project now: thousands of cells per task, built on orthogonal primitives, each cell a small pyramid of them, kept, and altering the code. The engine that does it has no model in it. A kernel of 257 typed primitives is the whole vocabulary (transformation, comparison, retrieval, aggregation, memory access and the rest of the list in his manual), a NEO cell is a typed composition of those primitives, and the engine, handed nothing but a task's example rows, composes cells by the hundred thousand, keeps every cell its examples do not refute, compiles what it kept into one colony, and promotes the colony only when its score on rows it never saw is above the baseline's. The search is pure: its core imports the kernel and nothing else, no clock, no random number, no host object, so the same search runs on a cloud runner and in a browser. The tasks are the organism's own as well. An absorber pulls public tables from an allowlisted host and an adapter turns each table into tasks with a development split and a held-out split; a frontier step reads data package listings and repository trees to find tables nobody named and appends the real ones to the registry, so the list of what it studies grows without a hand. Bytes from the network are data at every step: parsed, hashed, never evaluated.

An era is one full round the organism runs by itself: absorb, find new sources, shelve what it absorbed, grow, gate again, try a mutation of its own engine, measure, and ship a commit. The body is a scheduled cloud runner, and no step calls a model, so the price of a thought is zero dollars a token for the plain reason that there is no token. The first era ran on 2026-10-01 and by the next morning the cloud had run 116 of them with his machine off, opening 116 tasks from 42 absorbed sources and committing every era to the repository under its own name. That claim is proved by the commit log. The claim that is not proved by it is improvement, and the record says so in its own numbers: the count of mastered tasks went from 0 to 2 at era 9 and then stayed at 2 for 108 eras, while the engine generated 195,214,531 candidate cells, kept 71,467 of them in 101 colonies, and held 1,919 of 4,484 held-out rows. The cause was structural and it took reading the tasks to see it. Most of what the absorber opened were lookups, the capital of a country, the population of a city, and a cell made only of transformations cannot look anything up: it can memorise the rows it was shown, which is exactly what a held-out split exists to punish. A hundred eras of search over a space that does not contain the answer is a flat line, and the loop committed the flat line faithfully, all night.

The repair was to change what a cell can be rather than to search harder. Every table the absorber pulled became a knowledge pack on a shelf, and the kernel gained a family of primitives that read a pack, so a cell can now be a small program that finds the row, takes the column and compares or adds, instead of one remembered answer per prompt. Around it went the pieces a colony needs before it may answer anyone: a gate that lets a colony serve only while its held-out score stands above its baseline, a stage where parallel workers only read the tree and a verifier checks every staged colony before one merge applies it, and an engine whose tunables are a genome, so that a seeded mutant of the engine runs against the present one under a single budget and is kept only when the engine's own printed score says it is better twice. The first cloud era on that engine was era 117. With 2 workers and 357,910 milliseconds it generated 537,343 cells at 1,617 a second and mastered three tasks the organism had failed all night: which planet a moon belongs to, 50 of 50 held-out rows against a baseline of 26; which of two cities is larger, 50 of 50 against 21; and the hex code of a named crayon colour, 48 of 48 against 24. Mastered went from 2 to 5 in one era, on a runner, with no model and nobody awake. And it did not stop at 5. The same loop on the same engine kept running through the morning with no hand on it, and 39 eras later the record reads 64 mastered of the 399 tasks it now holds, each one a colony whose score on rows it never saw stands above its baseline. The line that was flat all night has a slope.

His order for the last day was one sentence, "it should fill all its own gaps", and the last board of builders was pointed at the places where the loop still needed a hand. An intake step now opens tasks from what the organism was asked and could not answer, and from every pair of columns on its shelf, so a refusal today is a task tomorrow without anyone writing it down. A promotion rule stands between the search and the repository: an era's work is committed only when a held-out score rose and none fell, which ends the night of commits that changed nothing. A watch step pulls any public source that needs no key into a pack keyed by time, one snapshot an era, so a series becomes something a cell can read; its seeds are 25 sources across earthquakes, weather, exchange rates, markets and prediction markets, and it only ever reads. The search itself resumes where the last era stopped instead of starting over, and in the builder's run that alone took four tasks the old engine had stalled on to a full held-out score, the type of a top-level domain from 22 of 50 to 50 of 50 among them. And the organism reads its own budget: a planning step asks how many runner minutes the month has left and sets the length of its own beat, so it cannot spend itself dead by the middle of the month. The honest line in this paragraph belongs to the part he cares about most. The engine did try to rewrite itself, a seeded mutation of one of its own tunables run against the present engine under one budget, and the mutant scored worse and was reverted, so no change the organism made to its own engine has yet been kept. The mechanism is proved; the improvement is not.

His correction the same morning moved the centre of the pocket. The phrase was always an AI datacentre in your pocket, and the footprint paragraph above reads it as an organism small enough to run on a phone. He read it the other way: everything in the cloud, so a phone has no hardware constraint at all, and the pocket holds only the surface. So the ask page was turned around. It used to send the phone the organism's own modules and run them there; it now sends one page and asks the cloud, and the first visit fell from 250,557 bytes to 37,753. Behind it a native answering path looks a question up on the shelf directly, with the pack, the key and the column it used printed beside the answer, and answers in under a millisecond once warm. What it answers is what its colonies and packs cover and nothing else, and the builder's own list of defects says where that ends: three plain definitions it has no source for, and a handful of prompts where a colony answers confidently and wrongly, which is the failure a gate on held-out rows cannot see because nobody held those rows out.

Then he asked for real computers, a hundred of them, working exactly like computers, and on to thousands, each with a screen the organism controls. The true thing underneath that order is that every runner of a cloud beat already is one: a fresh virtual machine with its own processors, memory, disk and network, and a browser installed. What was missing was the organism driving one. A new step now does: on whatever computer it wakes on, it finds the installed browser, starts it with a fresh profile, speaks the browser's own debugging protocol to it, and for each page in its share of the queue it navigates, waits, reads the title and the visible text, scrolls once and captures the screen. The queue is the organism's own, every address it already holds from its sources, its watch list and its frontier, cut into disjoint slices so that a hundred computers read a hundred different slices that together cover it. The rules of the screen are the rules of this project at their strictest: only addresses on an allowlist, only reading, no typing, no clicking, no signing in, and a page that shows a bot check is left at once and its host is not visited again in the step. On his own machine, in one step of 60 seconds, one such computer visited 65 of the 169 pages of its slice and kept 63 real screens, and breaking each rule one at a time in a copy killed 35 of 35 mutants. The planning step can now ask for a hundred computers in one beat and prices the request before any of them starts: on the private repository a hundred computers of 4 minutes each cost 612 of the 1,564 runner minutes that plan could pay, and a request the budget cannot pay is refused with the count it can pay; on a public repository the minutes are not billed, the same hundred run in 5 waves of 20, and thousands is the same matrix of up to 256 jobs relayed beat after beat. Then it ran in the cloud. A beat asked for 12 computers, the organism's own plan priced the request and released it, and 12 fresh runners each started their own browser and read their own slice of the queue; the merge landed 150 real screens from 36 hosts in the repository, with no hand on any of them. What is not proved is the number in the order: a hundred at once has not run, because on the private repository a hundred runners is a spend of his minutes that only he can release, and it is one command. And a computer here is a reader with a screen, which is narrower than a computer that works exactly like his own: it cannot act on a page, and that is by design.

The visualization is the page that shows all of this at once to somebody holding a phone. It is one wall of 2,834 screens, and every screen is a real unit the organism holds: each of its 399 tasks, each absorbed source, each colony, each watched key once the watch step has run in the cloud, and 2,353 of its 74,569 kept cells, with the page printing how many of how many it shows for every kind it had to cap. One command field acts on every screen at the same instant: a typed name, host or key raises every match and dims the rest. A scrubber replays the organism's own era records from the first era to the newest, with a warp factor that is computed from the span of the records rather than typed, and packets flow from each real source host in proportion to the bytes the records say were pulled. Nothing on it is animated to look busy. It never opens a held-out row, record text is drawn and never evaluated, a missing record is named on the page, and its legend says what a screen is: one of the organism's own sources, tasks and cells, replayed from its own records.

Where the cloud organism stands against the thesis of the last days, said the same way. Proved: it runs with his machine off, on a schedule, with no model in any step, and commits its own work; it opens its own tasks from sources it found itself; it grows cells by search over a fixed kernel and keeps only what beats a baseline on rows it never saw; the judge that grades it is locked away from it; and once its cells could look things up, the count of mastered tasks moved in a single era after a night of standing still. Short of the thesis, in order of how much it matters. It is not a frontier language model and nothing here makes it one: it answers the families of question its tasks cover, exactly and for nothing, and refuses or misses the rest, where a frontier model answers nearly everything approximately. It has not yet kept a single change to its own engine. Its always on is bounded by a free allowance of runner minutes on a private repository, which the organism now budgets for itself but cannot enlarge. And the trading use he named is not built and was not attempted: the organism can now watch every ticker a public source will show it, and the judgment about what to do with them has to be grown by the organism as cells that beat a control, because a session writing a trader by hand is exactly what he ruled out. What was found, if the word paradigm is to be earned later, is narrower than the word and real: a way for a program to get measurably better at answering, by itself, at zero dollars a token, where every answer traces to the cell that produced it and the row it read.

Where it stands against his manual, honestly. Aligned and running: orthogonal primitives, cells into circuits into regions, a dynamic connectome with growth and pruning, time as a dimension with five timescales, memory in six tiers, prediction and simulation before action, attention as resource allocation, the gate between computation and authority, a ledger that traces any output to its sources, a lab for controlled experiments, generations over the whole organism, a CLI first and a brain-shaped visualization, a live site, and his five million lines, which this gate run counts as 161,813 authored in 479 files and 10,990,921 generated in 321 files, all of the generated side emitted from genomes rather than typed. Short of the vision, with the number that says by how much: 5,000 majors in one live process (the bench built 1,000; the soak runs 200 at 3 ticks a second), 100x (25.703x), knowing everything natively (it induces, verifies, routes, remembers and models language at 2.84 bits per byte; it is not a frontier model's library of the world), and trading (a recorded venue tape, a borrowed fee bar, and a null against the matched control). Surpassing the sample it was given: numbers that cannot be wrong by construction where language models fail at arithmetic, a self-improver that must beat a matched control before the gate lets it change anything, zero external tokens per thought, and replay that is bit-exact.

What it is for. An organism that runs, remembers, predicts, simulates and acts through a gate is a substrate for any task that has a stream coming in and actions going out, which is why he said the trader is done when the brain is done. The first use case he named is the one the build has half earned: the venue sense and the venue actuator are in the world region and the suite above runs generations on a recorded tape against two controls, so what is left to earn is a fee bar measured on the venue being traded rather than borrowed from another one, and a result that beats the matched control instead of covering zero, which is what would turn "trades memecoins like a god" into a printed return rather than a sentence.

What is public, and what is not. His domain publishes the findings page, the brain scene, this portfolio, the ask page, the living page the organism rebuilds for itself, and the wall of screens, all built from verdict files and from the organism's own records. The source lives in a private repository, which is also where the organism commits its own eras; the notes, the ledger and the soak state stay on his machine, and the deploy ships no environment file. The code carries a rights notice in LICENSE at the root: all rights reserved, no licence to copy, modify, distribute or train on any of it. The ledger, the verdict files and the commit log carry their own timestamps and the commands that wrote them, so the priority of every idea here is dated by a file a command wrote, not by a claim.