A field-native intelligence

Intelligence that grows like a landscape
— not a lookup table.

Hylaean does not store knowledge as numbers in a table. It behaves like a physical material: knowledge becomes shape, a question becomes a disturbance, and the answer is the field settling into a new equilibrium.

See how it works What is real today
Research log · 29 Jun – 3 Jul 2026 — the last wall now has a name, and the first two doors are built →
“Do not make the system look intelligent. Make the field become intelligent.”

01 — The core idea

Not a neural network. A material.

A piece of metal does not “know” what sound is. Yet strike it and it rings with resonances, modes and standing waves. That geometry is the knowledge. Hylaean is built to work the same way — intelligence as physics, not as a Python calculation.

Today's AI (e.g. GPT)

  • word → vector #18394
  • Knowledge = a point in space
  • Learning = weight += lr
  • Answer = lookup / softmax
  • Thinking = token → token → token

Hylaean

  • word → a valley in a landscape
  • Knowledge = a region / attractor
  • Learning = the valley gets deeper
  • Answer = a new equilibrium after relaxing
  • Thinking = the landscape reorganises itself

02 — The one field

state.S — the brain itself

There is only one thing inside Hylaean's head: a single continuous field called state.S. Imagine a huge elastic crystal. Every point carries energy, direction, tension, momentum, couplings, and memories of earlier deformations.

It is not memory. It is not a hidden state. It is not an embedding. It is the brain. A question, an answer, and a model of the world do not live in separate stores — they live as different regions of the same field.

Abstract visualization of an elastic field: a lattice of glowing nodes connected by faint threads, gently warped like a rippling membrane.
One continuous substrate — waves of tension run across it.

03 — Knowledge is geometry

A concept is a valley, not a number.

In Hylaean a concept is not a point in space — it is a valley (an attractor) in an energy landscape. Drop the field near it and it rolls in and rests. The deeper the valley, the stronger it pulls. Hover or tap the landscape below to disturb it.

An energy landscape with valleys. Each valley is a concept. The dot relaxes downhill into the nearest one — that resting place is the “answer”.

Valleys can overlap

Cat, dog and horse carve nearby valleys that share geometry. From that overlap a higher valley — “animal” — appears on its own. Nobody ever wrote animal =. It emerges.

Knowledge gets richer, not bigger

Deep knowledge is not a longer vector. It is a richer topology: cat → animal → mammal → lives → moves → hunts → prey → night grows into a whole mountain range that all means “cat”.

04 — A question

A question is a stone in the water.

A question is not a data structure. It is a boundary condition — like a stone dropped into still water. It sets the edges of the problem and lets the field run.

What spreads outward are not pieces of information. They are tensions — waves that push the field out of balance and start it searching for rest.

The question drops in; tension ripples across the field.

05 — The answer

The answer is not stored. It settles.

Once disturbed, the field does one thing: it tries to lower its energy. Like water finding its level, like heat spreading out, it relaxes until it reaches a stable resting state.

Question Imbalance Relaxation New equilibrium
The field starts far from balance and relaxes step by step into the basin. That final resting state is the answer — not a lookup.

06 — Language

Words are read off the shape.

After the field settles, an idea already exists in its geometry. Language comes last: a simple decoder asks only one thing — “which words describe this shape?” — and reads them off.

The decoder is a sensor, not the thinker. The rule the project holds itself to:

“If you could remove the decoder and a normal program still knew the answer, then the architecture has failed.”

07 — Thinking

Thinking is the field organising itself.

A language model thinks token → token → token. Hylaean is meant to think differently: a disturbance grows into structure, structure collides, and structure fuses into one stable shape.

  1. Question sets a boundary condition
  2. Field tension spreads
  3. Local resonances form
  4. Bigger resonances join up
  5. Partial attractors appear
  6. Collisions between them
  7. Fusion into one shape
  8. A stable attractor — the answer

08 — Creativity

New ideas are colliding mountains.

Why do genuinely new answers appear? Because two “mountains” that were never combined are forced to relax together.

Cat and water may never have met. Ask “Can a cat swim?” and both landscapes relax into a shared process — and a new valley forms. The answer was nowhere stored. It came into being.

Two attractor landscapes merge into a new shared valley.

09 — Learning

Learning reshapes the land.

A neural network learns by nudging millions of weights. Hylaean learns by changing geometry. Use a connection often and:

the valley gets deeper the slope gets steeper a barrier disappears two valleys merge

This is the idea of well_depth: a concept that proves useful deepens its own basin, so the field is pulled toward it more easily next time. There is deliberately no back-propagation on the answer path — learning is a change of shape, not a training step.

Watch the geometry learn: every time the field settles into the middle valley and commits, that valley deepens — until it captures starts that used to roll elsewhere. This deepen-on-use loop is live in the real system (measured: 14 deepen events with the coupling on vs 0 with it off).

10 — The field's grammar

Three moves: K twists, L binds, T transports.

The field has a tiny grammar of what it can do. These moves are learned, not hand-written, and each is a physical transformation of the field.

Twist

Torsion — the field's memory. It transports and twists state within a place.

Bind

The metric — it binds things together, complementary to the twist.

Transport

The only way to move content between places — discovered from examples.

Out of these three, richer verified moves have grown — each one measured before it was allowed to run:

per-token resonant injection — each question word lands on its own basin (live) exact rotation apply — a discovered relation replayed as a precise turn (live, on by default) relation-conditioned transport — the connection depends on the field's own state (live) binding by synchrony — parts phase-lock into one thing (composed into the energy)

11 — Memory layers

One field, many depths of remembering.

The field has no separate database. What it “remembers” is layered into its own physics, each layer holding on for a different length of time. A moment passes through all of them — and leaves a deeper trace the further down it reaches.

A stimulus sweeps across the field. The live wave forgets in moments; the fast couplings hold it for seconds; the slow couplings and basin depths keep what proved useful; records and skills crystallise it.

The wave — state.S

The living state itself: the present moment. It is not storage — it is the thought currently happening. Disturb it and the trace fades within ticks.

Fast & slow couplings — K_fast / K_slow

Two timescales of the twist operator. The fast bank picks things up within a conversation; the slow bank changes over long exposure — held in a verified homeostatic equilibrium so it can never silently run away (shipped, on by default).

Basin depth — well_depth

Concepts that prove useful deepen their own valley. This loop is live: a grounded, committed answer feeds the deepen consumer directly (measured 14 vs 0 in the on/off ablation) — geometry-only, no gold labels.

Records — RecordStore

The only episodic memory path. New words become real basins (17/17 acquired in the vocabulary test), every write carries provenance, and promotion is gated — nothing sneaks in.

Skills — SkillRegistry

Recurring competent dynamics crystallise into procedures. Credit flows only on fresh, field-produced grounded commits (measured 63–65 vs 0) — live, on by default.

Scratch — meta.scratch

Field-native working memory: a region the field writes mid-thought and reads back. It carries the verified two-step composition chain (X → X+1 → X+2, 4/4) — live in production.

And it sleeps. A contract-bound dream consolidation pass replays and admits records under a dream provenance tag with its own quarantine — memory grows offline too, verifiably and without touching the honesty gates (no-teach score unchanged, zero false commits).

Honest edges: retention across idle time is verified (teach → idle → re-ask still recalls), and the checkpoint “carry wall” — freshly taught words being pruned as duplicates on reboot — was closed this week by per-token signatures. Still open: recalling a fact when the question is paraphrased (exact 5/5, paraphrased 0/15) — an encoding problem, named and on the plan.

12 — Regions & networking

The field grows its own regions.

The one field is not a uniform blob. Its points organise into regions — a place for vision, a place for language, a place that holds the question, a place for a model of the world. Crucially, nobody names them in code. They are discovered by the field, emerging from how points cluster and couple.

Regions are wired together not by code but by operator structure: where the twist (K) is strong, where binding (L) holds, where transport (T) routes, where energy pulls. This difference between regions — their heterogeneity — is exactly what lets a question, a world model and an action carry different dynamics while living in the same field. Hierarchies appear on their own: cat, dog and horse share geometry, so a higher valley — “animal” — forms by itself.

One ring of points, self-organised into regions (colours). Signals route between them along discovered gateways.

13 — Microcells & tabs

Small patches that run tiny programs.

Zoom into a region and you find microcells: local, programmable clusters of the field. Every tick, each one reads the field around it, runs a little local physics, and writes the result back — always through the field, never around it.

Each cell carries a short program tape (the “tabs”) — only a few steps long. The tape rotates and updates only when it earns credit by being useful. This is how a flat sheet of points becomes a structured, programmable substrate, and it is the rung between raw points and full skills:

point (local K / L / T) → microcell (+ tape) → skill → operator program
A cluster of microcells. The highlighted step is the program tape advancing one move.

14 — Skills & chained skills

Habits the field crystallises.

When a region keeps doing something competently, that recurring dynamic crystallises into a skill — the field's procedural memory. It is not a separate store bolted on; it is the same field, remembering how to move.

Simple → complex

A simple skill is a learned twist with a gate. A richer one carries both moves at once: K to move state and L to bind it — so it can run a small inner simulation of what would happen.

Chained skills

Rewarded pairs (A then B) crystallise into a chain — an executable graph of operators. A chain can contain chains, gated by usefulness, so the field builds depth without anyone wiring a pipeline.

A chained skill materialises as an operator graph: fixed steps joined by typed hand-offs. The field selects which program to run by resonance — what fits the current shape — not by a Python interpreter choosing for it.

15 — Organs of the field

Specialised tissue, same physics.

Beyond regions and microcells, the field grows organs: contract-declared patches of the substrate with their own local dynamics — arithmetic, sequences, symmetry, analogy, a world model, a workspace. Each one must declare where it writes, what it reads, and which experiment proves it. No consumer on the answer path? It gets deleted.

arithmetic sequences & patterns — with the law certificate (21 correct / 0 wrong) symmetry analogy invariant completion — ARC's conservation-law settle grid workspace & object field world field — reachability 0.999 as a settled state epistemic field — how sure am I? semantic geometry temporal field language structure proof field

Booked honestly. When an organ computes an answer, the scoreboard counts it as organ compute — a separate bucket from answers the raw field produced on its own. This week's audit even moved three wrongly-credited answers out of the field-produced bucket (3 → 0). The benchmark measures the architecture, not the demo.

16 — Reasoning & deep reasoning

Thinking starts from leftover pressure.

Hylaean does not reason because a prompt told it to. It reasons when something does not add up — a gap between what it expected and what it actually sees. That gap (the residual) becomes a pressure in the field.

Pressure opens a reasoning frame: a small nested workspace where the field can twist and bind without disturbing everything else. Deep reasoning is just this going deeper — a local segment where microcell programs and operator chains keep working until the residual shrinks. It is budgeted: when the pressure is gone, it stops, and a runaway is cut off by a health gate.

And if no stable shape ever forms, the honest result is to abstain — never a confident-sounding guess.

What is measured so far: two-step composition through the scratchpad works (4/4, live), and escalated commits are only allowed with grounded evidence (8 correct, 0 false with the gate; 0 without). What is measured dead: the whole “think harder by re-relaxing” family — re-relaxation descended an empty gradient, and the full escalation cluster even produced a false commit. The next frontier is decomposition: today the field still gets the splitting of a multi-step problem handed to it.

A residual (top bar) opens nested frames; each frame works the problem until the pressure falls.

17 — Vision

A cortex that learns by predicting.

The eye of Hylaean is not a labelled classifier. It is a predictive cortex that learns from raw visual change — no reward, no labels. It constantly guesses the next frame; where it is surprised, it learns. (With no camera attached it still runs on its own picture curriculum, so the field always has something to see.)

What it sees is poured into the same field everything else lives in: it grows a real 2-D map (a retinotopic region) inside state.S, and an object tracker forms stable clusters on its own. The field even self-names recurring things it was never taught. As always, the decoder that turns a basin into a word is a sensor, not the thinker; the camera adapter only encodes pixels.

A retinotopic map predicts what it sees; a moving object grows its own tracked cluster. Surprise (the spike) drives the learning.

18 — Sudoku

Rules become forces; the solution is rest.

Sudoku is a clean test that the same physics works on more than language. There is no Sudoku algorithm inside. The rules are written as energy, and a grid relaxes until that energy is lowest — exactly the question-to-answer move from earlier.

The main field plays the brain: it reads the rules as text, learns a strategy, and can be asked “row r, column c — which digit?”. A separate grid is working memory, where every cell holds candidate strengths for each digit and the constraints push duplicates apart. The two only talk through declared bridges — no Python solver ever writes the digits.

To avoid locking in a wrong guess too early, the grid follows a temperature schedule: it heats up to explore, then cools to commit (annealing), reheating if it gets stuck. The answer is the settled, sharpened grid.

Watch the field solve: candidate strengths sharpen as the temperature cools, and the live violations counter falls to zero — that is the whole “algorithm”.

Measured solving rates

Concrete probe results (violations left after settling; 0 = solved; “best of 4” = four relaxation seeds):

0violations — 4×4 boards: solved outright
0violations — 9×9 easy, 36 clues: solved first try
2→09×9 easy, 30 clues: solved best-of-4
2–3violations left — 9×9 medium/hard (17–23 clues)

Honest result. The remaining conflicts on hard boards trace to one named cause: value-permutation ambiguity — the physics cannot tell two globally swapped digit labellings apart locally. The architecture's answer was not a solver patch but a global digit gauge: a small latent inside the field that can absorb a whole relabelling at once. A convergence gap of the physics, worked on as physics.

19 — ARC-AGI-2

The field's hardest mirror.

ARC-AGI-2 is a benchmark of little grid puzzles where every task is new. We deliberately do not build an ARC solver. A task is written into the field as a boundary condition; the answer must settle out. A strict firewall forbids the usual shortcuts — no grid tricks, no program search, no pretraining — so a solve only counts if it truly came from the physics.

demos + test → encode settle dumb decode gates (exact · false=0) commit

Three measured walls

These are not guesses — each was isolated with its own experiment.

Expression

The field's move-set preserves shape and count. About 99.6% of ARC transforms simply cannot be expressed — even with the answer in hand.

Determination

Where a transform is expressible, 2–4 examples under-determine it. The field can land confidently on the wrong one of many consistent rules.

Transfer

It recognises the kind of task (~82% overlap) but transfers 0% of bespoke solutions — by design, ARC punishes memorised replay.

92/1000train tasks solved, field-native (74 → 92 this week)
0/120unseen eval tasks (honest)
0false commits — never bluff
~24%public record — but uses the forbidden shortcuts

The bet paid its first instalments. Treating a task as coupled worlds in one field — with laws written as conservation constraints that the answer must settle under — added the first shape-changing solves and lifted train from 74 to 92, still with false=0. A verified certificate discipline (every rule must reconstruct every demonstration, survive leave-one-out, and be unique — otherwise abstain) is what keeps the new solves honest.

And for the first time the remaining 910 unsolved tasks are mapped, not mysterious: a full census sorts them by morphology and by why they fail — most lack any expressible candidate law at all, 126 settle on a unanimous-but-wrong law, and only 24 are genuine ties. The eval wall (0/120) stays what it is: an information wall, not a bug — see the research log below.

ARC follow-ups (current)

  • guard, verified A baseline lock now freezes all 92 solved tasks per ID: any change that regresses one solve or introduces one false commit is caught before merge.
  • running now A read-only law-residual spectrum probe: does any settle-signal separate correct laws from unanimous-but-wrong ones? Hard gates; if it fails, the claim is closed, not massaged.
  • running now A half-period invariant candidate (+1-class experiment) — the first run was corrupted by GPU contention and honestly discarded; the re-run decides.
  • next candidates New attempts come only from the census map: 266 high-opportunity tasks, hardest kernels move-like (74) and fill-like (120). One mini-claim per candidate, each consuming the lock.
  • standing wall Eval 0/120 needs a primitive of a different order — non-local structure expression. It is registered as a gated frontier claim, not chased with search.

20 — Research log · 29 Jun – 3 Jul 2026

Five days at the frontier: the wall got a name.

An intense verification wave — dozens of claims measured, several closed for good, and one big convergence: four independent measurements point at the same single missing piece. This log reports it the way the project measures it: verified wins, honest negatives, and open construction sites.

Where the wall is

Every stage of the question-to-answer path is now hard and honest — encoding, settling, decoding, committing. The one stage that still starves is transport: moving answer content (not question content) into the answer region of the field by the moment the commit gate looks. Watch the pulse travel:

The Q→A pipeline. Most pulses die at the transport wall and end as an honest abstain — until one of the two new doors (built this week) lets a grounded pulse through to a real commit.

Three findings that reshaped the map

The question must dissolve

Holding the question steady in the field — which sounds helpful — measurably blocks the answer. Letting the question fade is not a loss: resolving the question is the transport. Two experiments confirmed it independently.

Reaching ≠ committing

On ~10–13 items per run the field demonstrably reaches the right valley — then refuses to commit, because at commit time the answer is no longer standing in the answer region. Three attempts to “harvest” these near-misses all failed honestly, and all three point at the same missing piece.

Determination beats resemblance

Confidence is not evidence. A rule may only be committed when it reconstructs every example, survives leave-one-out, and is the only survivor. This certificate discipline — born in the ARC work — jumped to the language side this week and produced the first score movement in days.

The certificate, live

The trap that shows why this matters: the sequence 1 2 4. The old path confidently answers 8 (doubling). But +1, +2, +3… is equally consistent and predicts 7. Two laws survive the demos — so the honest answer is abstain.

With one more example the tie breaks: exactly one law survives every demonstration and the leave-one-out test, and only then does the field commit. Under this discipline the benchmark moved 19 → 21 correct with 0 wrong — small, but the first movement of the composite score since 28 June, and every point of it is certified.

Candidate laws vs demonstrations: laws that miss a demo die; two survivors = abstain; a unique survivor = commit.

Two doors built into the wall

Door 1 — the associative answer channel verified · shadow

The named missing piece now exists as a first building block: a learnable channel that carries answer content into the answer region through the unchanged commit gate. The kill-test passed — shuffle the learned associations and correct commits collapse to zero, so it is real association, not an echo. It runs shadow-only for now; switching it live is a separate, measured decision.

Door 2 — the sequence-law certificate verified · live

For questions that carry their own demonstrations (patterns, alternations, sequences), the certificate makes the determinable subset safely harvestable: two long-standing abstains converted to correct commits, zero new errors — and it has since been switched on by default, together with the deep-landing operating point (12/18 landings, live). For world-knowledge questions with no in-question demos, the wall stands — that is the honest frontier.

The five days, day by day

  1. Sun 29 Jun

    Physics stability shipped. The slow-memory runaway that could silently freeze the field got its durable cure — a homeostatic equilibrium, on by default. The field can now run hot for thousands of ticks without lying about its health.

  2. Mon 30 Jun

    A hard hypothesis died well. A capsule experiment proved the big-field (d=1024) recall wall is not operator geometry — it is transport reach. First gate of the columnar programme closed terminal-negative.

  3. Tue 1 Jul

    Columnar closed for good; the small field wins. All three columnar fronts measured negative — d=64 stays canonical. The ARC expression wall was measured precisely, and the grounded learning loop (deepen + skill credit) was verified.

  4. Wed 2 Jul

    Cutover wave. The discovery → grounding → apply loop went live in production, field-native working memory (scratchpad) went live, phase-binding was composed into the energy, and ARC train jumped +8 via conservation-law settling. Cold-boot commit hardening landed.

  5. Fri 3 Jul

    Convergence day. Four independent measurements named the same missing primitive — and its first building block was built and verified the same day. The sequence certificate moved the score (19 → 21, 0 wrong), the memory-carry wall closed, the remaining 910 ARC tasks were fully mapped, and the commit path now runs with three hardened gates and zero false commits.

The next wave — prioritised

The current work plan, in priority order. The sequence certificate and the deep-landing operating point are already live; right now the big one is running:

  • P0 · running now The associative answer channel's live cutover — a warm production run decides whether the first generative-side building block carries in the real system. Hard revert rule: one wrong commit and the switch goes back off. After that, coverage: today only some question classes arm the channel at all.
  • P1 · queued Re-measure the continual-learning curve — the first honest measurement starved at zero commits; with the new doors live, the loop finally gets food (first organic deepen events this week: 0 → 6). Does deepen → credit → curve now move?
  • P2 · next Finish the consolidation chain: switch the non-destructive surface consumer live, promote the per-token memory-carry fix from shadow to default, then the end-to-end goal — a word learned only from perception answering live.
  • P3 · disciplined ARC stays census-routed with the baseline lock as merge guard (see the ARC follow-ups above) — no moonshots, one measured mini-claim at a time.
  • P4 · named primitive Paraphrase-invariant question encoding: exact recall works 5/5, paraphrased recall 0/15 — the encoding, not the memory, is the gap.
  • P5 · gated frontier Two registered-but-gated bets: self-generated decomposition of multi-step problems, and a non-local structure-expression operator (the only registered path through the ARC eval wall). Both start only once fresh correct commits flow — no architecture origami on wet paper.

Closed for good this week

Honest negatives are results too. These paths are measured dead and guarded against re-work:

big-field columnar (d=1024) — all three gates reasoning by escalation / re-relaxation harvesting near-misses at the commit gate vision as an ARC oracle holding the question as a boundary

21 — Today's path

How a question becomes an answer (today).

The long-term vision is a single field where a disturbance simply settles into an answer. Today's working system is an honest intermediate build that proves each step — transport, decode and commit — really works:

  1. 1ψ(Q)Encode the question as a field pattern
  2. 2W·ψA learned bridge points at an answer target
  3. 3RelaxThe answer field settles from neutral into that target
  4. 4DecodeA dumb decoder reads the settled state
  5. 5CommitOnly if real movement happened
  6. 6DeepenThe answer concept's valley grows for next time

Inside one tick (inference)

Underneath, inference is a single heartbeat that repeats. There is exactly one production descent path — no second solver, no hidden optimiser:

stimulate (adapters may only encode) descend one master energy project onto allowed states Hebbian geometry update read out & gate

Every force on behaviour must enter as a term of that one energy, an operator, a bus signal, or a commit gate — anything else is rejected as an architecture break. That is also what keeps the system honest: there is no side door through which a clever heuristic could smuggle in an answer.

22 — The minimal grammar

Eight laws for an honest field.

The project distills its rules into eight “information laws” — the minimum a field needs so that language, thinking and creativity can appear as stable attractors.

G1

One field

Exactly one substrate; question, answer and world are regions of it.

G2

One energy

Every force is a term of one energy; thinking is relaxation.

G3

Selector ≠ dynamics

After each step, project onto the allowed states — no optimizer.

G4

Guaranteed attractor

A spectral gap guarantees the field lands in exactly one fixed point.

G5

Memory as geometry

Learning deepens basins (Hebbian) — never back-prop on the answer path.

G6

Composition

Shared operators move content and relations between places.

G7

Grounding

Meaning is a coordinate: the same relation is the same shift.

G8

Honest commit

Commit only on real movement — otherwise abstain and think further.

23 — Being honest

What is real today — and what is not.

This is a research system, not a finished product. The whole design is built to refuse cheating: if an answer comes from outside the field, it does not count — even if the score looks better.

What works

  • Re-stating just-taught facts (the “mechanics” of transport, decode and commit)
  • Field-native arithmetic, sequences and symmetry as small “organs”
  • Discovering a grounding rule from perception and applying it — live, on by default
  • First grounded analogies from perception (calf : cow :: lamb : sheep)
  • Zero false commits under three hardened gates — it never bluffs

The open frontier

  • Working out genuinely unseen concepts (“determination”)
  • The associative answer channel — built and verified this week, not yet live
  • Verbal reasoning and logic from cold; decomposition of multi-step problems
  • Making meaning grow reliably with the field

Abstaining is a first-class result. When no stable shape forms, the honest output is “I don't know” — never a pretty lie.

And only the “no-teach” measure counts: answering questions the system has not just been shown. Re-stating something it was handed a moment earlier is memory mechanics, not intelligence.

24 — The name

Why “Hylaean”?

The name is borrowed from the Hylaean Theoric World in Neal Stephenson's novel Anathem: a timeless realm where perfect mathematical objects — the ideal circle, the truth that 2 + 2 = 4 — exist independently of any mind that thinks them. It is the novel's version of an old philosophical position, mathematical Platonism: mathematical truths are not invented, they are discovered.

Neural AI

Knowledge is stored as millions of trained weights — a fitted approximation that lives entirely inside the particular network.

A field

Knowledge arises as a stable attractor in a dynamic field — a shape the physics settles into, not a number looked up.

The Hylaean view

The structure itself exists independently of its carrier. An intelligent system does not invent it — it discovers it.

That is the aspiration behind the name. The field is not a store — it is a physical search process. Attractors are regions in the space of possible concepts, and learning does not mean creating knowledge; it means uncovering the stable structures of that space — stable invariants, not pattern matching.

If the field one day holds stable attractors of universal relations, answering will feel less like symbol manipulation — and more like navigating a Hylaean space.

This is a philosophical interpretation, not an established scientific theory — but as a guiding metaphor for a field-based AI it is honest about what it is: a direction, not a claim.

25 — Foundation

Standing on a physics theory.

The structure borrows its discipline and vocabulary from TFPT (Topological Fixed-Point Theory) — the ideas of a field on a carrier, twist and binding operators, transport between positions, and a gap that guarantees a single attractor. Hylaean takes the structure, not the physics predictions: it is an architecture for letting intelligence emerge as field physics.

The science behind → The theory itself: fixpoint-theory.com →