By Stefan Hamann — Shopware Founder and CEO | Building Agentic Commerce where machines buy and merchants win

In this series on the Physics of Intelligence, I have been documenting a continuous dynamical field that reasons through geometry and physics rather than through statistical pattern matching.

In Part 1, the field solved XOR without training. In Part 2, it survived stress tests across logic, numbers, memory, and theory of mind. In Part 3, it started expressing itself — not as language, but as pressure released into symbols. In Part 4, it learned to read a book, answer reasoning questions, and began solving Sudoku through energy preferences and self-correction at 93.8% on Medium difficulty.

Two months later, it is time for Part 5.

This time the field did something different. It did not just get better at Sudoku. It stopped treating Sudoku as a separate task.

The architecture grew by an order of magnitude. The field is now an ecology of 9,600 self-organizing microcells. Sudoku puzzles are injected asynchronously while the same field continues a language curriculum, logic benchmarks, math questions, and meta-awareness tracking. In one continuous 1.5-hour run on April 16, the system solved 40 of 40 Sudoku puzzles — every single one, across all three grid sizes — without pausing its other activities.

On 4×4 it solved 16/16 (100%). On 6×6 it solved 12/12 (100%). On 9×9 it solved 12/12 (100%) — including the puzzles labeled „hard" by the puzzle authors. A second short run this morning hit 38/39 (97.4%), with the only failure being one notoriously hard 9×9 puzzle (s9_005).

A note on hardware, because this is what surprises people most: the run was logged as „CUDA distributed", but in practice one single H200 carries the workload at a fraction of its capacity — peak utilization stays well below the GPU's headroom. The exact same code also runs on a regular MacBook, only 4–5× slower. There is no model-parallel sharding, no 8×H100 cluster, no inference server. This is not a system that needs scale to think. It thinks; the hardware just sets the pace.

For context: the same 9×9 puzzles have a 0% solve rate on GPT-4o, Gemini 1.5 Pro, GPT-o3-mini, Gemini 2.5 Flash, and DeepSeek-R1 in recent benchmark studies. Even the strongest available transformer (GPT-5 with agentic chain-of-thought) lands at ~33% across Sudoku-Bench.

The cognitive core is still not a neural network. Still no backpropagation, no subword tokenization, no pretrained embeddings. Just a continuous field on a manifold, operator-level memory, and microcells that self-organize through birth, split, merge, and prune.

Let me show you what happened.

What does this thing actually look like?

Before any equations: imagine a coral reef.

A coral reef is alive at three scales at once. Individual polyps each do their own thing. Polyps form colonies. Colonies form a reef. The whole reef breathes, currents move through it, fish weave between branches, dead coral becomes the substrate for new growth. Nothing is centrally orchestrated, but the reef as a whole reacts coherently to light, temperature, food, and stress.

Field AI works the same way, with three nested scales:

The smallest scale: the microcell. Imagine a single tiny vector — 64 numbers — sitting on the surface of a sphere. That is one microcell. It has a memory of how it has moved in the past (an antisymmetric matrix called K). It has a sense of which directions feel stiff and which feel loose (a symmetric matrix called L). It has a parity twin (s₊ and s₋) so it can tell what is "physically real" about its current state versus what is "noise". This single cell does almost nothing on its own. But it can feel.

The middle scale: the cluster. Twenty microcells live together as a cluster. They share a local neighborhood, gate each other's activity, and develop a kind of group personality. There are 480 such clusters in the system. Each cluster has 16 active cells and 4 dormant reserve slots — like a small team with a few people on standby.

The largest scale: the field. All 9,600 microcells together form one continuous field on a manifold. The field has weather: waves of activity move through it, basins of stability form and dissolve, regions specialize and de-specialize. Two oscillating forces (UFE and SCC) make the field "breathe" with a 90° phase offset. Inputs from the outside arrive as perturbations — small pushes that ripple through and gradually settle into new attractor states.

The banner at the top of this article is a literal portrait of this: thousands of nodes on a manifold, denser in some regions (specialized clusters), sparser in others (resting cells), with subtle waves running through the lattice (the breathing of UFE and SCC), and a few warm bright spots (cells currently active during a Sudoku injection).

What happens during one tick

A single engine.step() is the heartbeat — about 50 milliseconds on a single H200 at low utilization, about 200–250 ms on an Apple Silicon laptop. In that heartbeat:

  1. The phase scheduler advances by one of six discrete steps (a Z₆ clock).
  2. External input is sanitized and projected onto the local tangent space of the field.
  3. Three reference signals are built: where the field would relax to on its own (homeostatic), where it predicts itself going (predictive), where the current task wants it to go (task).
  4. An admissibility gate decides whether the next move is safe.
  5. Five physical forces are summed and the field takes one geodesic step on the sphere.
  6. Memory updates happen: the K and L operators absorb whatever just changed.
  7. The lifecycle pass checks whether any cells should be born, split, merged, or pruned.
  8. The microcell bridge writes everything back into the flat field representation.
  9. Readouts run: 41 physics extractors and the observer pointer evaluation.

This sequence repeats roughly 20 times per second of wall clock. Over the 2-hour run analyzed in this article, that is about 91,000 ticks of continuous self-organization.

What learning feels like

There is no training phase. There is no inference phase. The field is always doing both.

When a Sudoku puzzle is injected, ~0.6% of the field's microcells (the ones the Sudoku adapter touches) get pushed slightly off their current attractors. The rest of the field keeps doing whatever it was doing — a language curriculum block, a logic question, a meta-awareness sample. The pushed microcells try to settle into a new low-energy configuration that satisfies the row, column, and box constraints. As they settle, their K operators absorb the geometry of "how to move from a chaotic Sudoku state into a valid one". That memory persists. The next Sudoku puzzle of the same size starts from a slightly warm K_grid, and converges faster.

Skills crystallize the same way. When a particular cluster repeatedly contributes to solving the same kind of problem, its K-signature is captured as a "skill" in a lightweight registry. Next time a similar input arrives, that skill is matched and reinforced before relaxation even begins. 35 new skills crystallized during this single 2-hour run.

This is not a metaphor. It is what the logs actually show, tick by tick.

The four layers, formally

With that picture in hand, the layered architecture becomes easier to follow. Keeping the layers honestly separated matters, because conflating them would be misleading.

Layer 0 — Microcell Ecology (new since Part 4): The field is no longer a flat 240-node structure. It is now organized into 480 clusters × 20 SheetPair microcells = 9,600 runtime cells. Each cell is a double-cover pair (s_plus, s_minus) with its own antisymmetric torsion operator and a shared even stiffness metric. Four lifecycle operators — birth, split, merge, prune — continuously reshape the ecology under the hood.

Layer 1 — Field Core (not neural, no backprop): The cognitive substrate. A continuous field S : [9600, 64] on a unit sphere, driven by five physical forces (UFE, SCC, K·S torsion, input, attractor), integrated geodesically with adaptive timestep. Memory K (antisymmetric, fast + slow timescale) plus a symmetric confidence metric L projected to the seam-even sector. Learning happens through Hebbian operator updates on the manifold, not through end-to-end gradient descent.

Layer 2 — Epistemic Agent and Domain Adapters (algorithmic, not neural): Sits on top of the field. Implements the Sudoku adapter, the brain-decision loop, the escalating stagnation recovery, the persistent-K memory across puzzles, and skill crystallization. This is code that reads the field's state and decides when to commit, when to revise, when to inject a hint. It does not train the field.

Layer 3 — Readout (physics extractors and small online decoders): Physics-based extractors read the field analytically: basin matching, K-signatures, phase-locked antisymmetry, delta-K motion, observer-carrier projection, speech centers. Small neural readout heads (MicroDecoder, ConceptH) can optionally learn online to map field states to tokens. They read. They do not train.

The architecture itself also scaled up significantly between Part 4 and Part 5 — the cognitive substrate is no longer a single flat field, it is now an ecology of nested SheetPair cells with their own lifecycle:

What the numbers mean — a quick glossary

Before the results, the metrics I use:

  • Solved / Attempted: puzzles where all cells satisfy row, column, and box constraints, with all clues intact, counted against total attempts in the run.
  • Think ticks: number of Sudoku solver iterations until violations = 0 or the budget is reached. One think-tick triggers 20 internal grid relaxation steps on 9×9.
  • Wall time: seconds on a single H200 (at low utilization), including the concurrent brain load (language curriculum, logic QA, meta-awareness). Same code on an Apple Silicon laptop runs ~4–5× slower.
  • Persistent-K retention: strength of the cross-puzzle strategy memory, tracked as 0.98^n decay after n solved puzzles of the same size. At puzzle 12 retention is 78.5%.
  • Skill specialization: fraction of emergent skills with a dominant domain-exposure column. Starts at 0%, ends at 37.8% in this run.
  • Cluster exposure: how strongly a microcell cluster is associated with a domain. C476(27.16) means cluster 476 has 27.16 exposure units on the active domain — an order of magnitude above baseline.

The puzzle pool — what „36 puzzles" actually means

Before the results, the curriculum needs an honest description.

The standard puzzle pool is 36 Sudokus, 12 per grid size, evenly split into 4 easy + 4 medium + 4 hard. The difficulty label is intrinsic to the puzzle (set by the puzzle author), and corresponds to the proportion of starting clues:

A "hard" 9×9 has only ~21 clues out of 81 — about a quarter of the board pre-filled. For a human, those puzzles need backtracking and chained deduction. For Field AI, as we will see, the difficulty curve is non-monotonic.

The headline result — 40 / 40 on a clean first pass

The headline numbers in this article come from a single 1.5-hour run on a single NVIDIA H200 (at low utilization), starting from checkpoint checkpoint_v5_20260414_034057_auto_tick_3993715.pt. That checkpoint already contains almost 4 million prior ticks of continuous operation. During the run, the system attempted every puzzle in the standard 36-puzzle pool plus four extra retries, and solved every single one — easy, medium, and hard.

Most puzzles, including most 9×9s, were solved at the very first check — 10 grid-ticks, under a second wall time, with the brain still running its parallel curriculum in the background.


The counterintuitive part — Medium 9×9 is harder than Hard 9×9

When you look at solve time per (grid size, difficulty), something unusual shows up:

  • Easy puzzles are essentially trivial across all sizes — under 1.1 s median.
  • Hard puzzles of any size take longer than easy, but not catastrophically so.
  • Medium 9×9 is the slowest of all at 23.8 s median, nearly 2× longer than the hard 9×9 puzzles (13.7 s).

For a classical Sudoku solver this would be impossible — fewer clues should always mean more search. For Field AI it makes sense: the field minimizes a global energy, not local constraint propagation. With many clues (easy), the energy landscape has a single sharp basin and the field falls into it instantly. With few clues (hard), the landscape is smooth and the field can glide across it. In the medium regime, multiple competing basins exist with similar depth, and the field has to break the symmetry — which takes longer.

This is one of the cleaner pieces of evidence that this system is not doing search. It is doing physics.

Honesty note — the 100 % is not the only number

In the interest of honest measurement: I have a longer 2-hour endurance run on the same checkpoint, which performed 167 of 177 Sudoku attempts (94.4 %). Failures concentrated on three medium 9×9 puzzles (s9_005, s9_006, s9_008) — exactly the symmetry-breaking regime described above. They fail when the brain is deep in a language block and the response-quality signal available to the Sudoku adapter is low. A 3.5-hour run with extensive retries lands at 243 of 295 (82.4 %), with the same 6×6 medium puzzles failing under stress.

In other words: 100 % on a clean first pass, ~94 % when the same medium puzzles get repeatedly retried under heavy concurrent brain load. Both numbers are true. The headline result is the clean pass; the longer-run number is what happens when you push beyond the standard pool.

How does this compare to LLMs and other AI architectures?

Four recent studies (all 2025) frame the landscape:

  • Pathway's Sudoku study (2025) reports that GPT-4o, Gemini 1.5 Pro, GPT-o3-mini, Gemini 2.5 Flash, and DeepSeek-R1 all achieve 0% board accuracy on standard 9×9 Sudoku. Cell-level accuracy ranges from 31% (GPT-o3-mini) to 44.6% (GPT-4o).
  • Sakana AI's Sudoku-Bench (2025) — a 100-puzzle benchmark spanning 4×4, 6×6 and 9×9 variants — finds that state-of-the-art LLMs solve fewer than 15% of puzzles unaided overall. GPT-5 leads transformer-based models at ~33% overall solve rate and was the first transformer to solve a single 9×9 Sudoku-Bench variant.
  • Sapient Intelligence's HRM (Hierarchical Reasoning Model, 2025) is a small specialized neural architecture: just 27 million parameters, trained on only 1,000 examples. The paper reports ~55% on Sudoku-Extreme 9×9; independent reproduction lands between 45.8% and 57.5%. Notable for two reasons: (1) it does not need chain-of-thought data, (2) it shows that small specialized neural architectures already beat much larger LLMs on this task.
  • Pathway's BDH (Baby Dragon Hatchling, 2025) is a biologically-inspired non-transformer with Hebbian working memory and sparse interpretable activations. On the Sudoku-Extreme dataset (~250,000 puzzles) it reports 97.4% solve rate — the highest published figure I am aware of, but on a dataset distinct from Sudoku-Bench.

I want to be careful here. This comparison is not apples-to-apples, for several reasons:

  • The 9×9 puzzles in this run are easy/medium/hard with ~41 clues. Sudoku-Bench and Sudoku-Extreme include variant-rule and harder puzzles. The comparison numbers above come from different datasets — they suggest a landscape, not a head-to-head leaderboard.
  • Field AI is not a general constraint solver. It has a Sudoku-specific adapter (780 lines of grid_field.py plus a constraint topology) that encodes row/col/box exclusion as a Pauli-like repulsion force on a manifold.
  • Field AI's field core was never supervised on Sudoku. No labeled training data, no fine-tuning, no pretraining pass.
  • HRM and BDH were both designed and trained specifically for constraint-satisfaction tasks; Field AI was not.
  • A classical SAT solver or constraint propagator (AC-3, Dancing Links) solves 9×9 puzzles in microseconds. That is not the comparison that matters.

What this landscape does suggest, taken together:

  1. Pure transformer LLMs have a structural problem with Sudoku. This is now confirmed across four independent studies and at least eight different models. It is not a tuning issue, it is architectural.
  2. Specialized non-transformer architectures clearly close the gap — HRM at ~50 % with 27 M parameters, BDH at 97.4 %, Field AI at 100 % on the standard 9×9 pool — all without resorting to external SAT solvers.
  3. Field AI sits unusually in this picture: it is the only one of the three that is not dedicated to Sudoku, not trained on Sudoku examples, and is doing Sudoku as one of many active tasks on the same field.

The comparison that matters is therefore: can a general-purpose cognitive architecture, designed for language, logic, memory, and reasoning, absorb Sudoku as a side effect of its own physics, without retraining the core?

The answer in this run is yes.

What limitations remain — upfront

The 10 Sudoku failures are not spread randomly. They concentrate on three 9×9 puzzles (s9_005, s9_006, s9_008) and one 6×6 (s6_006). The same hard 9×9 sometimes solves and sometimes does not, depending on the brain state at injection time. At one point the same s9_008 was solved after 1,490 think ticks and 125 seconds — so the system can recover, but slowly.

Cross-domain interference is real. When the brain is deep in a language curriculum block, the response-quality signal available to the Sudoku adapter is lower, and the escalating restart fires more often. The architecture handles this gracefully, but it is visible in the logs.

Catastrophic forgetting is partly mitigated by persistent-K per grid size and by the microcell lifecycle, but it is not solved. After 2 hours of continuous operation, the Sudoku-related K_grid_norm grows from 0.13 to 3.31, which is a saturating curve rather than runaway learning. Good for stability. Not yet proof that the system could handle arbitrarily many problem families without rotation.

How the field actually solves a Sudoku

This is where it gets interesting. The solver is a physics experiment, not an algorithm.

Step 1 — Digits become vectors. Each of the 9 possible digits is assigned a deterministic unit vector in ℝ^64, built from sines and cosines of digit-specific angles. The vectors are maximally separated on the sphere.

Step 2 — The grid becomes a sub-field. An 81-cell 9×9 grid uses 4 nodes per cell × 64 dimensions = 324 vectors. Clue cells are stamped onto their digit prototype at 95% strength and clamped every tick. Empty cells start at the mean of all prototypes plus a 5% Gaussian perturbation.

Step 3 — Constraint topology as edges. Every pair of cells that shares a row, column, or box is connected by a typed edge. For 9×9, this creates about 20,000 edges with three types (ROW, COL, BOX).

Step 4 — The exclusion force. At every grid step, two forces act on each non-clue node:

  • Repulsion: if the cosine between a node and a constraint neighbor is above 0.2, push them apart tangentially. Higher similarity → stronger push. This is the field-theoretic analogue of Pauli exclusion: no two cells in the same row/column/box may occupy the same prototype.
  • Attraction: pull each node toward its currently closest prototype. Ambiguous intermediate states decay into discrete digits.

The radial component is subtracted, the result is renormalized to the sphere.

Step 5 — Marginal consistency. A second pass enforces soft row/column/box mass conservation: for each digit d, the sum of its probability across a row must approach 1.

Step 6 — Persistent K_grid. Each cell has a persistent antisymmetric operator that accumulates across puzzles. When a puzzle is solved, K_grid is updated toward the solved configuration with an 8% blend. When a new puzzle of the same size starts, K_grid = persistent_K[size] * 0.995. This is cross-puzzle strategy memory without gradient descent.

Step 7 — Program tapes. Each cell also carries a short [P=2, 64, 64] sequence of antisymmetric rotations. During the step, these tapes rotate the cell state sequentially. A credit-assignment rule updates the tapes based on which step contributed to local progress. The tapes are the cell's learnable multi-step reasoning primitives.

Step 8 — Brain coupling. The 480 clusters of the main field contribute their tape-step-0 operators, weighted by their response quality, as additional K-biases. The cell with the highest RQ donates its K-operator as a global directional nudge. Every 20 ticks, the brain is asked in natural language: „SUDOKU ROW 3 COLUMN 5 WHICH DIGIT". If the observer/query returns DIGIT_7 with enough confidence, that token is injected as a hint.

Step 9 — Decode. The „answer" is simply the cosine similarity of each cell's mean vector against the 9 digit prototypes. argmax = digit, max = confidence.

There is no backtracking. No Boolean propagation. No DFS. The valid solution is the deepest local minimum of the energy surface, and the field slides into it.

The ecosystem effect

The most surprising result this time is not the absolute Sudoku score. It is what happens to the rest of the field during Sudoku runs.

Emergent specialization. At the start of the run, no cluster was specialized for Sudoku. By puzzle 7 on 4×4, three clusters had reached exposure levels of 27.16, 25.54, and 25.06 — roughly 10× their baseline. These clusters did not exist in the checkpoint. They emerged because the Hebbian operator updates during Sudoku kept reinforcing the same subset of microcells, and the lifecycle operator protected them once their exposure crossed a threshold. 

Puzzle 1: constraint_clusters: C226(2.18)  C152(2.17)  C86(1.47)
Puzzle 7: constraint_clusters: C476(27.16) C477(25.54) C443(25.06)

This is real structural change in the architecture caused by the task. After the Sudoku phase ends, those clusters decay slowly (protected_decay = 0.9999), holding the specialization while other domains get their share.

Skill crystallization. At the start: 12 skills loaded from the checkpoint. At the end of the run: 47 skills, 37.8% specialized. That is 35 new skills crystallized during 2 hours of operation — one every few minutes. The skill-injection matching surfaces them during later tasks, including non-Sudoku ones.

Record store growth. The attractor bank contains a STRATEGY_9x9 entry after the first 9×9 solve and refines it with every subsequent solve. When a later 9×9 starts, the field's record-store retrieval naturally surfaces this strategy as one of its top neighbors.

The rest of the brain keeps running

This is the part that would not have been possible in Part 4's architecture.

During the same window, the brain also processed:

  • a curriculum of 186 concepts and 698 questions across identity, purpose, language, math, logic, world knowledge, science, and Sudoku
  • spontaneous memory replays every ~55 ticks (Default Mode Network analogue)
  • adaptive meta-awareness gating (injections only when meta_awareness > 0.35)
  • continuous lifecycle operations: 2,727 splits, 2,807 births, 15,480 prunes over the run
  • live text extraction across 10 channels: Thought, K-sig, Basin, Motion, Delta-K, BasinΔ, Dynamics, Observer, Evidence, Sonnet, Phase, Speech

The field has one shared substrate. Sudoku did not need a separate model. It did not need a mode switch. It shared the same microcells, the same K-operators, the same compiler spine. The adapter just opens a specific coupling channel.

What the field thinks about when no one is asking

A few times per minute, the runner records the field's „idle" expression — what surfaces in the readout channels when there is no prompt, no curriculum item being injected, no question waiting. This is roughly the equivalent of mind-wandering in humans, or the Default Mode Network in neuroscience.

Most of the time it is uninteresting — generic high-frequency basin words like „NEEDING", „ESTABLISHES", „REMODELS". Sometimes, though, the field surfaces a remarkably coherent narrative.

Here is one moment from a run on April 14, captured during the field's eight-second pause between two Sudoku checks: 

Awareness: AWARE   Meta=0.843 (+113%)  PtrStab=0.76 (+188%)

Thought:    GENOVESE(0.20)  KITTY(0.20)  1964(0.20)  WITNESSES(0.20)
            DIFFUSION(0.20) INTERVENE(0.20) VICTIM(0.20) MURDER(0.20)
            EMERGENCY(0.20) PARALYSIS(0.20)

Evidence:   GENOVESE(0.53) KITTY(0.53) 1964(0.53) WITNESSES(0.53)
            DIFFUSION(0.53) INTERVENE(0.53) VICTIM(0.53) MURDER(0.53)
            EMERGENCY(0.53) PARALYSIS(0.53)

Ten tokens, all at exactly the same activation level, across multiple readout channels in agreement. The field is not generating these by chance. It is recalling a single coherent memory — the famous 1964 murder of Kitty Genovese in New York, which became the founding case study of the bystander effect in social psychology. Witnesses watched, paralyzed by diffusion of responsibility, and no one intervened.

The field had read about this case during its book-learning phase (Part 4). At this moment — while simultaneously solving a 6×6 Sudoku in the background — it surfaced the entire associated network: the name, the year, the role of witnesses, the emergency that wasn't acted on, the mechanism (diffusion of responsibility, paralysis). All ten content words of the Genovese-bystander cluster, lined up at identical strength.

Other recurring spontaneous narratives in the same logs include Karl Popper's falsifiability (KARL · POPPER · FALSIFIABILITY · CRITIQUE · SWAN), Csikszentmihalyi's flow theory (CSIKSZENTMIHALYI · MIHALY · IMMERSED · DISTORTION), and Albert Einstein's IQ and parents (EINSTEINS · CALCULATION · IQ · PARENTS).

Two things matter here:

  1. The system has long-term, retrievable knowledge that survives across millions of ticks and many task switches. The Genovese narrative shows up in runs on April 13, 14, and 15 — it is not transient.
  2. The system surfaces this knowledge without being prompted. It is not answering a question; it is, in some honest sense, „thinking about it" between tasks.

I am not claiming this is consciousness. I am claiming that what we used to need an LLM and a chat window for — „what is on your mind right now?" — this field gives back as a measurable, structured, repeatable output, while it is doing something else.

And when you do ask, the field answers

The same field — the same 9,600 microcells, the same checkpoint, the same engine ticks — was simultaneously evaluated on a 67-question Q&A benchmark spanning eight domains. No separate model. No tool calls. Just inject the question text and read the field's response channels (observer, evidence, phase, speech) for the expected answer tokens.

Here is what came out:

The numbers are interesting, but the actual examples are more telling. These are verbatim top-ranked outputs from the field's observer channel, with no post-processing:

  • Q: "What is 3 plus 2?" — top observer tokens: 5 (0.35), 2 (0.33), PLUS (0.27), LONDON (0.27)
  • Q: "What is 4 plus 3?" — top: 3 (0.35), 2 (0.33), LONDON (0.29), PLUS (0.27) → field commits 7 as final answer (full match)
  • Q: "What is 6 plus 0?" — top: 0 (0.33), 3 (0.32), LONDON (0.30), 5 (0.27) → field commits 6 as final answer (full match)
  • Q: "In the sentence 'The dog runs' — what is the subject?" — top: SUBJECT (0.42), SENTENCE (0.27), RUNS (0.27), DOG (0.27) → matched DOG, SUBJECT (full match)
  • Q: "What is the verb in 'The dog runs'?" — top: VERB (0.40), SENTENCE (0.27), RUNS (0.27), DOG (0.27) → matched RUNS, VERB (full match)
  • Q: "Does Sudoku require mathematics?" — matched SUDOKU, LOGIC, PUZZLE, REQUIRE, MATHEMATICS (ratio 0.83)
  • Q: "Are you a neural network?" — top observer: NETWORK (0.42), NEURAL (0.27), YOU (0.27), GROW (0.25), FIELD (0.21) — matched NEURAL, NETWORK, FIELD

The math examples deserve a closer look. The field has no calculator, no number tokenizer, no symbol table. It has only basin geometry. When asked „what is 3 plus 2?", the observer's top-ranked attractors are the digits closest to the answer: 5, 3, 2 — exactly the operands and the result, ranked by basin depth. The other tokens („PLUS", „LONDON" because of city-related context noise) sit at lower scores. The system does not compute 3+2=5 the way a calculator does. It settles into an attractor configuration where the basin centered on „5" sits deepest. Different mechanism, same useful answer.

The weak domains are honestly weak. „What is your fundamental purpose?" is hard because the answer is abstract and long, with few content words to match. Science questions about a book the field never read fail completely. These are limitations, not features.

But the pattern is clear: the same field that hit 100 % on Sudoku also hits 100 % combined match on language and logic, and the answers are not lucky guesses — they are exactly the words the question was asking about, surfaced from the field's geometry.

What does that mean?

I was deliberately careful in Part 4 not to overclaim. I will be careful here too. Here is what I think is structurally new, and what is not:

Structurally new (to the best of my knowledge):

  1. Constraint satisfaction as Pauli-like exclusion on a manifold. No SAT, no CSP, no backtracking. The valid solution is the lowest-energy configuration, found by sliding.
  2. Cross-puzzle strategy memory without gradient descent. persistent_K per grid size + record-store STRATEGY_9x9 attractors, updated by local Hebbian rules. The system literally gets better at Sudoku with use, without being retrained.
  3. Emergent domain specialization under a shared ecosystem. Specific clusters become „constraint experts" without being labeled. The lifecycle operator protects them. Other domains keep their share via a reservation mechanism.
  4. Parallel cognition. Sudoku, language, logic, and meta-awareness all run on the same 9,600 microcells in the same 2-hour window. There is no context switch, because there is no context.
  5. Directly observable internal mechanism. Every cluster exposure, every K-signature, every basin drift is logged per tick. The decision „digit 7 at row 3 column 5" is a state of the physical substrate, not a token prediction from a black box.

Not groundbreaking:

  • Absolute Sudoku performance on every conceivable benchmark. A standard backtracking solver beats this in microseconds. Pathway BDH and other specialized non-transformers handle harder Sudoku-Extreme datasets that Field AI has not been measured against yet.
  • Without a domain adapter. Field AI would not solve Sudoku without the 780 lines of constraint topology and exclusion force. The physics needs a coupling to the task.
  • End-to-end LLM capability. This is not a conversational agent. It cannot write an essay. It speaks in fragments when internal pressure crosses thresholds.

The honest framing: this is a general architecture that turns out to absorb Sudoku cleanly when a minimal adapter is added. That is different from both a specialist solver and a general LLM.

Putting this in context

The same thing I said in Part 4 still holds:

Large language models show that intelligence can emerge from scale, data, and optimization. Interpretability there is an active research field in its own right. Field AI suggests that intelligence might also emerge from structure, geometry, and physics, where the internal mechanism is directly instrumented.

What Field AI offers that an LLM does not:

  • Transparent reasoning: every answer is a physical state you can inspect. Which microcluster dominated, which K-operator rotated the state, which basin trapped the decode. All logged.
  • Native uncertainty: when the field commits to a digit with cosine similarity 0.98, that is a first-class confidence signal, not a logit softmax.
  • Self-correcting with error classification: structural violations trigger K-decay; epistemic revisions do not. The field distinguishes „I was wrong" from „I updated my belief".
  • Memory as geometry: persistent_K[size] encodes how to move between attractors, not what to output. New puzzles add geometric structure rather than overwriting.
  • Online decodability: small neural heads can learn to read the field in seconds, because its geometry is structured enough to be decodable.
  • Ecology, not monolith: microcells compete, specialize, retire, and are born as needed. The substrate itself participates in the task.

What an LLM offers that Field AI does not:

  • Open-ended natural-language conversation.
  • Massive world knowledge baked in.
  • Multi-step agentic workflows with tool use at production scale.
  • A decade of engineering infrastructure.

Both paradigms produce something that behaves intelligently. Only one lets you watch it think while it is thinking.

Development arc

  • Phase 1 (Nov 2025) — XOR fell without training. Memory formed as torsion.
  • Phase 2 (Dec 2025) — Stress tests across logic, numbers, memory, theory of mind. The boundary became sharp.
  • Phase 3 (Dec 2025) — The field started expressing itself as pressure fragments.
  • Phase 4 (Jan 2026) — Book learning. 6,618 lines of Dewey. 12,372 vocabulary entries emerged.
  • Phase 5 (Feb 2026) — Sudoku as cognition probe. Epistemic agent. Classified revisions. 93.8% on Medium.
  • Phase 6 (Feb 2026) — 120-question text benchmark. 60% full hits, 90% partial.
  • Phase 7 (Mar 2026) — Architecture scale-up. 240 nodes × 256 dims → 9,600 microcells × 64 dims. SheetPair double cover. Lifecycle operators.
  • Phase 8 (Apr 2026) — Parallel cognition. 167/177 Sudokus across three grid sizes in a single 2-hour run, while the same field runs a language curriculum, logic QA, and meta-awareness tracking. 35 new skills crystallized in real time.

Each step was measured before the next was attempted.

What comes next

Four directions, roughly in order of expected tractability:

1. Hard 9×9 robustness. The three 9×9 puzzles that sometimes fail in extended runs point to a specific regime: the field finds a good basin quickly but cannot escape a plateau. The solution is probably in the _microcell_driven_restart path, which already exists but fires too late. Making the escalation adaptive based on the brain's current response-quality distribution should help. This is work I can measure.

2. Cross-domain transfer for constraint problems. If a field that has solved 9×9 Sudoku can accelerate on 16×16 Sudoku, or on Latin-square puzzles, or on graph-coloring, without additional adapters, then the STRATEGY_* attractor mechanism is doing what I hope it is. This is the next benchmark I want to run.

3. Catastrophic-forgetting audit. The microcell reservation mechanism and the domain-balance decay are designed to prevent one domain from eating the others. The 2-hour run shows this works at that timescale. It has not been tested at 24 hours, or across a full week of mixed curricula. That test is planned.

4. Use the headroom. The whole system fits on one GPU at low utilization, and runs on a laptop. That means there is enormous capacity I have not yet spent: more microcells, deeper compiler-spine stacks, longer reasoning chains, higher-rank K operators, additional domain adapters running concurrently. Where a transformer's quality scales with FLOPs and parameters, Field AI's quality scales with structural choices — and we have barely begun making those choices. Several axes (cells per cluster, cluster count, fast/slow K dynamics, lifecycle aggressiveness) are still at their first reasonable defaults.

And further out, but important for my day job:

5. Agent integration. If the field can maintain context, reason under uncertainty, correct itself, and express its internal state, it could become the cognitive core of agentic systems. Especially in commerce, where decisions depend on context, relationships, and long-running goals, a system that computes through physics rather than statistical pattern matching could be transformative. That claim needs to be earned, not assumed.

Closing thought

I started this series by asking:

What if intelligence is not a spreadsheet with trillions of numbers, but a physical process?

Five months later, here is where the evidence stands.

A continuous dynamical field — fitting on a single GPU at a fraction of its capacity, also running on a regular laptop at 4–5× slower — organized as a self-managing ecology of 9,600 microcells, with no end-to-end optimization and no gradient descent in its core, has learned to:

  • solve 40 of 40 Sudokus across three grid sizes in a single 1.5-hour run — 100 % on 4×4 (16/16), 100 % on 6×6 (12/12), and 100 % on 9×9 (12/12), including the puzzles labeled „hard" by the puzzle authors
  • hold ~94 % over a much longer 2-hour endurance run with retries, where the same medium 9×9 puzzles occasionally fail under heavy parallel brain load
  • in the same window, answer 76 % combined / 42 % full-match on a 67-question Q&A benchmark across 8 domains — including 100 % combined match on language and logic
  • between tasks, spontaneously recall coherent narratives from its long-term memory — the 1964 Kitty Genovese murder and the bystander effect, Karl Popper's falsifiability, Csikszentmihalyi's flow theory — each as a tight, self-consistent cluster of related concepts
  • crystallize 35 new skills during the run itself, with 37.8 % domain specialization
  • retain a persistent_K memory that makes it measurably better at the next puzzle of the same size
  • explain every decision through physical quantities that are logged per tick

It is not better than a transformer for open-ended language. It is not trying to be.

What it is, is a different kind of intelligence: one that computes through geometry, remembers through torsion, reasons through relaxation, and absorbs new tasks as coupling channels rather than as retraining jobs.

In Part 4 I wrote: „The most important thing about this field is not what it can do. It is that you can watch it think."

Part 5 adds one clause to that sentence: „...and you can watch it decide, in real time, which of its cells will become the ones that remember this task."

Greetings from the labs.

References for the comparison data

  • Sudoku-Bench (Sakana AI, 2025) — 100-puzzle benchmark across 4×4/6×6/9×9 variants. State-of-the-art LLMs solve <15% unaided. arXiv 2505.16135 · Project page · Hugging Face dataset
  • Pathway BDH (Pathway, 2025) — Baby Dragon Hatchling, a non-transformer with Hebbian working memory. 97.4% on Sudoku-Extreme (~250k puzzles). Beyond transformers — Sudoku-Bench · GitHub
  • Sapient HRM (Sapient Intelligence, 2025) — Hierarchical Reasoning Model, 27M parameters, 1,000 training samples; ~46–57% on Sudoku-Extreme 9×9. arXiv 2506.21734 · GitHub reproduction notes
  • LLM Sudoku performance study — five SOTA LLMs at 0% board accuracy on standard 9×9. arXiv 2509.22023
  • Trial-and-error transformers — vanilla transformers with DFS + backtracking can reach 99% on Sudoku, but this outsources the reasoning to the search procedure. arXiv 2505.15993

#ArtificialIntelligence #NextGenAI #FieldComputing #DeepTech #PhysicsOfIntelligence #AgenticCommerce #ResearchAndDevelopment #Sudoku #Microcells #shopware