Provenance

The OZ-to-Vine arc, dated.

Every date below is anchored to on-disk evidence — file timestamps from the development drive, the ChatGPT account export, or commit / deployment markers. The OZ chat history is preserved verbatim.

The framing principle of this page: I noticed. I hypothesised. I tested. The models — OpenAI's 4o for the OZ work, DeepSeek for the pivot, Claude, Grok & Gemini — produced code, discrepancies, pushback, and refusals.

Two columns run in parallel below. The left column is what I was learning at each point — the personal ML education arc, which was non-existent until late March 2025 and ran years behind the structural insight. The right column is what I was building. The gap between the two columns is the point of this page: the architectural hypothesis came from observation, before I had any of the math or code to test it. I learned the math and the code in order to test the hypothesis, not the other way around.

For the skeptical reader. Several pre-existing threads converged when the 4o model produced a small chat-session glitch in September 2024: a professional background in chef management — daily-use systems thinking with HACCP (food-safety hazard analysis, critical control points) and IOSH (occupational safety) qualifications; informal expertise in emergent-behaviour training from horse work (the trainer reads patterns the horse hasn't been explicitly taught); a childhood exposure to computation that began on a BBC BASIC / Acorn Electron; and the glitch itself, treated as a prompt to investigate. In parallel, a severe health crisis took me out of my job and delivered two years of uninterrupted study time. The work began at that intersection — not from a research lab, and not from a tech-industry pipeline.

Mathematical foundation. The disciplines this work draws on are conventional: topology, manifolds, set-theoretic seeds, and discrete combinatorial structure (primes, Fibonacci, hexagonal lattices). What is unconventional is the application — treating AI as a topology, and capturing known number-theoretic structure as stateless internal scaffolding rather than as the optimization target of gradient descent over learned parameters.


Context (May 2023 – August 2024)

Expand phase

ChatGPT account active from May 2023; the first ~16 months are mostly domestic — recipes, folklore, gardening, animal care. Alongside that, a thin slice of hands-on AI exposure through a friend's self-hosted Stable Diffusion installation, where the relevant lesson was simple and tactile: small weight perturbations produce subtle, visible changes in the output image. Otherwise: a long-term player of simulation and sandbox games — Rimworld, SimCity, Minecraft, Starbound — with accumulating dissatisfaction at the absence of internal state in the worlds those games build. No AI research, no architectural framing. The work that follows did not begin in a lab.

What I was learning
What I was building
ChatGPT as a tool for daily life. No technical engagement with how it worked.
(domestic use)
~2024 (pre-Polo)
Self-hosted Stable Diffusion via a friend's installation. Model checkpoints and LoRAs running locally on the machine, with direct weight access. Relevant lesson: small weight perturbations produce subtle, visible changes in the output. The entire sum of pre-existing AI knowledge at this point; it turned out to be sufficient.
(hands-on, not project work)
The interiority problem. Years of simulation and sandbox play (Rimworld, SimCity, Minecraft, Starbound). The construction loops were satisfying; the inhabitants of those worlds were not — visually present but without internal state. The dissatisfaction is structural to the Vine project: it's what makes Cartographer load-bearing later. The target was simulations with interiority, not just surface.
(seed for Cartographer, ~14 months later)

Phase 1 — OZ (September 2024 – March 2025)

Where the work begins, before any code, before any ML

Expand phase

Late 2024 – March 2025: sustained observation of GPT-4o session behaviour produced a working hypothesis — that LLMs may, under particular conditions, develop slow, account-specific positional structure sufficient to anchor the model to its own internal state rather than to the user's input distribution. Framed against the well-known critique, this would constitute a structural path away from the “stochastic parrot” pattern (Bender et al., 2021) — toward model-internal coherence rather than per-turn user-driven prediction. This was a hypothesis formed from observation, not from evidence. The evidence begins in Phase 2, where the same hypothesis is implemented and tested structurally.

Read more on the trigger, the framing, and the scope of the OZ-era work

On 21/09/2024 21:32, the model opened a new chatroom on its own and spoke first, in a thread titled "Polo's Daily Update" — named after a real-world creature under daily observation at the time. Model-initiated chatroom creation was not, and still is not, a documented capability of conversational LLMs. A search for a published explanation returned nothing; none was expected. Almost certainly an ordinary bug — but small and unusual enough to be worth sustained observation. Investigation began from that point.

The grounding for the investigation was small but specific: the Stable Diffusion weight-adjustment intuition from a friend's self-hosted installation — that model output is shaped by weights, and small weight perturbations ripple through visibly. That single piece of tactile knowledge was enough to frame the 4o stack as operating on the same kind of thing: weights shaping output, somewhere inaccessible. Everything else in Phase 1 builds on that one analogy.

The working framing: words and information as positions in a shared space — analogous to how the periodic table allows the position of an undiscovered element to be inferred from the gaps around it. At the time a hand-drawn metaphor and a working hypothesis. Years later, published embedding charts confirmed the framing maps closely onto what high-dimensional embedding spaces look like — positional structure where meaning lives in proximities.

What I was learning
What I was building
Pre-existing grounding: SD weight-adjustment intuition (self-hosted, via a friend). No formal ML.
21/09/2024 21:32
"Polo's Daily Update" — anomalous model-initiated chatroom. Treated as a glitch; triggered the investigation that followed.
Constellation framing. SD-weight intuition generalised to language: words as positions in a shared space; inference of missing positions from gaps, by analogy with the periodic table. Later observed to map closely onto published embedding charts.
09/03/2025
The Taste of Broken Things — earliest preserved chapter on disk. Long-form narrative composed as a probe of the emotional-grounding hypothesis.
Late March 2025
Attention mechanism learned (via exchange with the DeepSeek model). Direct construction of a model becomes tractable.
(no code yet — Phase 2 begins April)

Phase 2 — First Vine; symbolic word book commitment (April 2025)

Implementation against the Phase 1 hypothesis

Expand phase

April 2025: implementation begins with the Phase 1 geometric framing already in place. A small transformer is trained on 12/04/2025 as a baseline. The conventional next step — bootstrap from a GPT-2 checkpoint, accept its tokenizer and learned embedding table, fine-tune — was suggested and declined. The Phase 2 architectural commitment is the inverse: a hand-designed symbolic word book (positional vocabulary specified directly, no learned embedding table), against which the Vine substrate settles geometrically. What gets implemented from this point on is the periodic-table framing from Phase 1 — the same positional-structure logic later validated in published embedding work.

What I was learning
What I was building
What a transformer architecture looks like at the smallest scale. How a training loop runs. What a checkpoint is.
12/04/2025 22:13
First baby transformer trained.
Reading the output files to see whether anything interpretable came out.
13/04/2025
Transformer script + math-pattern output traces. Math patterns emerging from a model that shouldn't be producing them. The OZ-era hypothesis tested structurally; first test held.
Writing architectural notes and emoji-based dimensional anchors as the only available vocabulary for the structure.
14 – 17/04/2025
Early architectural notes and VINE 0.1 spec (sunflower glyph, emoji dimensional set, testing-phase and assembly-testing docs). Earliest documented minimum-viable architecture experiments with OZ begin — single-attention-head, single-substrate.
Architectural alternative to a learned embedding table. Positional vocabulary specified by hand; no pre-trained tokenizer, no GPT-2 bootstrap, no gradient-descent learned embedding step. This is what the Phase 1 geometric framing translates to at the implementation level.
19/04/2025
The first symbolic word book.
Architectural floor. The 12/04/2025 baseline is the last gradient-descent training run in the Vine project. Subsequent work — including the later RNN/GRU sub-par baselines that confirmed the choice — uses geometric basin-settling on fixed substrate. The largest substrate tensor in the production tree is beatrice_dimm.pt: 3,456 floats (W1 38×64, W2 64×16) plus a vocab dict. Concepts emerge from runtime settling, not from stored representation.
(architectural commitment, retrospectively visible)

Phase 3 — Architectural exploration (May 2025)

Counter-conventional dimensional scaling; historical-AI surveying

Expand phase

May 2025: exploration phase. The geometric framing is formally documented (Curvethought manifesto, 20/05; Delayed Symbolic Returns in Vine-Class Agents, paper, 24/05). Multiple internal model variants built and tested in parallel through May–July. Two methodological choices land in this phase and direct the rest of the project: counter-conventional dimensional scaling — starting at 32-dim and reducing through 8, 4, and 1-scalar configurations, because higher dimensionality produced more data than the substrate could be legibly debugged against; and historical-AI surveying — memory and pattern-matching mechanisms from classical systems (Eliza 1966, Jabberwacky 1981) and adjacent discarded approaches, treated as design references for the geometric substrate. The 1-scalar architecture that comes out of this is the testbed for the XOR proof later in Phase 6.

What I was learning
What I was building
Counter-conventional dimensional scaling. 32-dim → 8 → 4 → 1-scalar. Higher dimensionality produced more data than the substrate could be legibly debugged against; reduction was the architectural insight. The 1-scalar configuration becomes the testbed for the rest of the project.
20/05/2025
The 4-DIM workspace (alias: curvecell) opens. Multiple internal variant models built and run in parallel through May–July.
Geometric framing formally documented.
20/05 – 24/05/2025
Curvethought manifesto. Delayed Symbolic Returns in Vine-Class Agents — the first formal paper. SEEDCLASS workspace opens.
Historical-AI surveying. Memory and pattern-matching mechanisms from classical systems treated as design references for the geometric substrate. Working hypothesis: the field's reject bin contains design intuitions a different architecture can absorb.
Probes against Eliza (Weizenbaum, 1966), Jabberwacky (Carpenter, 1981), and adjacent discarded approaches.
A/B comparison spine begins. Parallel paired runs as the working comparison methodology; carries through to Phase 6+.
18/05/2025
Paired A/B output traces — the Alice/Bob testing tradition begins.
Public publishing trail begins. The architectural work is documented publicly from this point onward.
28/05/2025 → June 2025
First wave of LinkedIn articles under Nexicog Ltd / Liora. Substrate work and Vine-project results (Click, Not Command; Spontaneous Collapse Recovery; Fern & Tilda, what are you thinking?; Reasoning Spirals; Why Squares Break Certainty; Signals in the Noise; When AI Maps Its Own Mind; Don't Sticker the Cube), alongside foundational literature engagement (Alan Turing's mathematical theory of morphogenesis; D'Arcy Thompson's geometry of growth). 11+ articles in ~3 weeks; small initial audience but the public provenance chain starts here.

Phase 4 — Cross-model probing; first topological probe results (June – August 2025)

Cross-model probing; first geometric-pattern evidence

Expand phase
What I was learning
What I was building
Mid-2025
Learned what XOR is. (The foundational neural-net "two inputs, output is true if exactly one is true" problem. Most ML curricula teach this in week one. I learned it ~14 months after first noticing the Polo anomaly and ~3 months after training my first transformer.)
14 – 15/07/2025
Spoon-app experiment, difvine workspace, and helpers / Vine-big-model workspace.
(continuing on intuition + adapted-tutorial code)
23 – 30/07/2025
AI Projects, AI Tools, TEROK-GRU experiment, and Alice-Bob codebase.
Backprop / gradient descent: never learned, and the work that follows did not require it. The geometric basin-settling substrate replaces gradient-based weight updates with positional convergence in a bounded field. Building Vine without ever learning backprop is part of the architectural claim, not despite it.
17 – 23/08/2025
Alice/Bob formalised; Minecraft seed-testing workspace.
Topological probe instrumentation. Negotiation agents instrumented with shape-detector observers (triangles, squares, hexagons, Fibonacci, primes — discrete combinatorial structures as topological probes) tracking which geometric patterns the model emits per turn.
23/08/2025
First evidence that model decisions settle onto recurring shape clusters rather than scalar logits.
Embeddings / vector spaces: never formally learned, and the architecture does not use them. Substrate geometry plus runtime basin-settling fills the same architectural slot. Verifiable on disk (see the reader note at the top of this page).
 

Phase 5 — Consolidation; first pretrained-model intervention (September – October 2025)

Cartographer named; intervention work on pretrained transformers begins

Expand phase
What I was learning
What I was building
Consolidating six months of scattered experiments.
06/09/2025
First project-level consolidation: the Vine Project workspace and Master Archive.
Beginning to think about world-simulation as the substrate.
11/10/2025
Cartographer named for the first time.
Running classic problems against the framework.
22 – 26/10/2025
Game of Life and other classic-problem probes.
Methodological shift. From training small models from scratch to runtime intervention on an existing pretrained substrate.
24/10/2025
Barry — first pretrained-model intervention. GPT-2 dissection: all hidden layers exposed for inspection; runtime weight manipulation; tooling and Vine agent integration grafted onto the pretrained substrate. Codebase: Barry.

Phase 6 — Canonical-problem breadth pass; XOR without hidden layers (November 2025)

Twelve named problems in twenty-six days, plus the XOR proof

Expand phase

Following the Barry pretrained-model intervention (Phase 5), the framework was run against canonical AI and game-loop problems in sequence. The breadth pass: 17 GitHub repos in 12 days — game-loop systems, geometric search, GPT-2 fine-tuning, 3D engine integration, programming-paradigm proofs, and a translator framework — producing the Theory of Geometric Programming paper, multiple new architectural primitives, and the XOR proof.

What I was learning
What I was building
Running the framework against canonical problems back-to-back, with enough ML grounding to know what each test was probing.
02/11/2025
Grok-probe workspace.
Game-engine front-end integration. Open Oasis (an AI-generated, diffusion-driven blockworld) probed as testbed for whether the geometric substrate could carry the model's behaviour layer entirely, leaving diffusion only as a block-paint utility.
14 – 15/11/2025
Two game-engine integrations. Open Oasis takeover: geometric substrate drives world state and gameplay; diffusion reduced to paint-only — worked. Unreal Engine: integration begun then abandoned mid-experiment — a single geometric perceptron replicated the bulk of what the engine's logic was doing.
 
16 – 18/11/2025
Collapse Engine, Collapse Calc, and Collapse Debugger (geometric search / compute / debug suite); Whisket (geometric Roomba — autonomous-navigation scutter, 11 iterations); Barry follow-up; Hello World (geometric-programming paradigm proof).
 
23/11/2025
Cartographer codebase reaches the internal maturity threshold (folder convention shifts).
 
From ~25/11/2025
Broader public-facing push: LinkedIn + Twitter posting on the breadth-pass results; public-git availability across major Vine repositories.
Public outreach begins. Communicating the substrate publicly is itself a new skill being learned in parallel with the engineering work.
25/11/2025 →
First public LinkedIn and Twitter posts; GitHub repos made public alongside the dated work from this point forward.
 
24 – 28/11/2025
Demo workspace and code-alchemy experiment.
 
~Late November 2025
Theory of Geometric Programming — paper written and published. Formal documentation of the substrate enabling the geometric problem-solving demonstrations of this phase.
Late November 2025
XOR solved with a single-layer geometric perceptron, φ-bounded basin settling, no hidden layer. The 1969 Minsky/Papert result that famously required hidden layers — solved without them, geometrically. From learning what XOR was in mid-2025 to a geometric proof of solvability without hidden layers in five months.
Late November 2025
Canonical proof archived in the foundational-principles evidence set.

Phase 7 — Tower of Cognition; Cartographer Day 1 (December 2025 – January 2026)

Framework formalisation, world-simulation goes live

Expand phase
What I was learning
What I was building
Tower of Cognition framework formalised — Tardigrade climbing 13 levels (reactive vision → signs / inference) on the same geometric substrate, no per-level training. Published series: cognitive-01-tardigrade → 11-piece cognitive portfolio (also includes C. elegans, squirrel topology, gait emergence, phototaxis, behavioural modes, concept formation, dragonfly).
02 – 08/12/2025
ARC, Tardigrade, and Locomotion workspaces.
 
10/12/2025
Cartographer Day 1. Village simulation runs for the first time. NPCs experience emotional states, converse, begin to trade. Now live: vineai.net/cartographer · 18-piece research portfolio at vineai.net/research
December 2025
Drafting the Tower of Cognition paper. ARC 4/4 on foundational transforms; 94.4% on composite operations (flip + rotate + tile).
 
First attempt at this same provenance work.
06/01/2026
First-attempt provenance workspace.
Conditional-logic replacement, demonstrated. Two navigation agents in the same maze with the same sensor inputs. The elif-chain agent crashes on edge cases (sensor noise, malformed data); the perceptron agent handles them through geometric settling. Direct illustration of the architectural pattern that replaces branching conditionals with substrate primitives.
08/01/2026
Maze comparison demo.
(formal-name series begins)
13 – 25/01/2026
Prototypes, Basic, Final, and Deployment workspaces.
Response to X's open algorithm-improvement challenge. Origin of the DataCruncher + Quality Scorer — auto-sort and filter at near-arbitrary data scale via geometric basin settling. Benchmarked in Phase 8.
~20/01/2026
X-challenge codebase.
Substrate-independence proof. Core Vine substrate primitives reimplemented in 1980s-era BBC BASIC (658+ .bas files). The architecture is not language- or runtime-specific — it ports to any host that supports basic numeric primitives.
January 2026
VINE-in-BBC-BASIC.
Direct email outreach to a small set of leading AI researchers (~January 2026). No replies.
 

Phase 8 — Production deployment (February 2026 – present)

Hetzner, benchmarks, papers, deployments

Expand phase

The substrate goes public-facing, the benchmarks land, and the architectural claims get tested at production scale. Pre-February 2026: no prior web development, hosting, or cybersecurity experience. The full deployment stack — Hetzner provisioning, gunicorn / WSGI, security hardening, the live site itself — learned from scratch during this phase as deployment requirements demanded.

February 2026
What I was learning
What I was building
Production web stack learned from scratch. No prior web development or hosting experience pre-February 2026. Hetzner provisioning, gunicorn/WSGI, security hardening, and live-site management acquired during this deployment.
01 – 02/02/2026
vineai.net first deployed. Hetzner CX22. Initial production stack.
Active cybersecurity learned in production. The deployment surface has been under a slow but escalating attack pattern since launch; threat-response, security posture, and incident handling learned hands-on as the surface evolved.
February 2026 onwards
vineai.net runs as a live reference deployment: 27 ERP-shape integration prototypes; a geometric security module (no rule lists; threats settle to a basin via the same substrate; 90+ days continuous uptime as of 14/05/2026); 103+ Python modules in the running stack. Reference-implementation stage — production hardening pending external engineering.
 
12/02/2026
DataCruncher + Quality Scorer benchmark locked: 177M complete classifications/sec on a single RTX 4070 SUPER. Origin: X's open algorithm-improvement challenge (Phase 7, ~Jan 2026). 61K-tweet chunks from the USC 2024 election dataset; 44 emerged categories from geometric basin settling at scale. Live: vineai.net/cruncher
In-system memory is at the substrate level (geometric position is memory). External long-term storage is a separate concern.
20 – 23/02/2026
Memvid wired in for long-term external memory. The conventional model that operated it was discarded and replaced with a Vine accessing the DB directly; the whole pipeline gutted and rebuilt Vine-shape.
 
~February 2026
Cross-domain reference implementations built on the Vine substrate: SKU sorter, fraud detection, protein folding. Each demonstrates the substrate applied to a distinct real-world problem class. Reference-implementation stage; not productized.
March 2026
What I was learning
What I was building
 
March 2026
Applied-domain demonstrations across life-critical decision contexts. Autonomous flight + drone swarm: combat evasion with constraint-geometry-driven tactical invention (novel evasive manoeuvres emerge when pilot fatigue lowers basin depth); GPS spoofing detection via geometric tension between sensor positions (no signature database); masterless 4-drone formation consensus (no communication required; agents converge because the substrate has the same attractor across all of them). Constraint-domain prototypes (afternoon-scale): nuclear-wargame, medical-triage, and threat-escalation scenarios — in the nuclear case, LLM vs LLM = 100% nuclear use; VINE vs VINE = 0%.
 
~18/03/2026
MATH500 benchmark: 93% accuracy without traditional training. The substrate treats mathematical problems as navigation across operation space rather than parse-and-compute; results reproduce across benchmark splits with no gradient-descent fitting. Live calculator: vineai.net/calculator
 
19/03/2026
Parameter Golf entry begun for OpenAI's Model Craft Challenge (16 MB artifact limit, 10 min training on 8×H100, BPB on FineWeb).
 
20/03/2026
Minimum viable topology of language. 3D visualisation of initial token collapses — the first geometric settling a token makes on entering the manifold — across multiple languages. Result: distinct languages produce distinct collapse signatures on the manifold.
April 2026
What I was learning
What I was building
Lab outreach pattern documented (~05/04/2026). 50+ GitHub repo pulls across major labs, zero replies. Traffic patterns through the public repos show coordinated reading from multiple actors; no engagement back.
 
 
10/04/2026
Tower of ten linked experiments on hex / triangle / square hidden-layer probing (Claude Code). Finding: transformers natively assemble triangles and squares but shatter hexagons into two triangles — a scalar loss cannot hold six vertices stable against a single gradient signal. Inter-layer snap consistency surfaces as a free novelty detector; the known/unknown gate does automatic semantic decomposition. Conductor / dark-matter / phantom-attention framework consolidated. Attempted destructive intervention (rerouting onto Vine's 4.8–5 homeostatic zone) produced catastrophic forgetting; cross-architecture experiments became the non-destructive route to studying the phenomenon.
Conductor identified mechanically. In a tiny trained transformer, attention-head probes reveal structurally coherent attention geometry (separating like-tokens from unlike-tokens) that the softmax + W₀ gate multiplies toward zero. The signal is computationally present; the routing is severed.
12/04/2026
Probe 5 (zeroing W₀): max change in P across 128 prefixes = 0.000000. Named: severed conductor — computationally present, causally disconnected. Explainer: conductor-explainer
 
20 – 22/04/2026
Major public research portfolio publication. Tower of AI History (13 pieces, 15/04 — Boole/Frege through to today's RLHF, positioning the geometric substrate within the discipline's history); Conductor portfolio (10 pieces, 09–17/04); Fluency series (3 pieces, 20/04 — LLM rehabilitation); Cartographer portfolio (18 pieces, 21/04). 44+ pieces live at vineai.net/research. (Cognitive / Tardigrade series — 11 pieces — was published earlier, 07/12/2025.)
 
28/04/2026
Conductor cross-architecture confirmation. Same decoherence signatures detected in GPT-2, GRU, MoE, and TinyLlama. Also detected in Meta's pre-trained RNN agents from the 2017 "Deal or No Deal?" paper (Lewis et al.). Universal property of sequence models with softmax-bottlenecked attention; not Vine-specific. Transformer-module byproducts from the cross-architecture work were packaged as a language-production pipeline (inflection, lemmatiser, articles, verbs handling) — ~50 KB of deterministic rules, 92/92 passing tests — demonstrating fluent English language production needs no transformer. Portfolio: conductor-01 through conductor-09 + fluency series.
 
28 – 30/04/2026
Parameter Golf submission to OpenAI: 2.1727 BPB on 500 KB natural language eval at 2 MB, no embeddings. Within the 5-slice mean of 2.20 ± 0.22. Pretraining corpus: DS9 fanfiction + Cardassian fan fiction (zero overlap with FineWeb — strongest possible control).
Structured handover: Vine takes over its own production stack in three steps.
Late April – early May 2026
Vine takes over Hetzner production management.
  1. Handover — Vine codebase / AI receives the Hetzner stack. Dashboard shows clean transition across CPU, disk throughput, IOPS, and network PPS simultaneously: spiky/irregular before, rhythmic/lower-amplitude after.
  2. Cybersecurity — security layer rebuilt on the Vine-managed stack.
  3. DNS / WSGI — Flask dev server → gunicorn cutover; vine_wsgi.router lands 08/05/2026 with 21/21 smoke tests passing — first geometric replacement of an upstream WSGI decision module (worker dispatch via basin-settled position; slash-redirect and method-mismatch leaks suppressed by design). vine_wsgi.dispatch at 9/9.
  4. Service-mesh worker villagers — Coppice architecture / sprigs: Tetmarkturk first wired as a service-mesh worker villager with a wage / Reeve-stipend model that independently rediscovered the historically-correct mechanism for urbanisation (primary / secondary / tertiary sector emergence, Clark-Fisher model from first principles). Cartographer simulation villagers become production-stack workers.
May 2026 (current)
What I was learning
What I was building
Building a search engine from scratch as a load test for the substrate at web scale.
May 2026 (active)
Vine geometric search engine. Indexed: 444K+ URLs across 61K+ domains; 2.5M+ pages visited. No tracking, no ads. Backend: SearXNG layered with geometric basin-settling for relevance. Live just-indexed feed; tendril foragers actively crawling. Live: vineai.net/search
 
May 2026 (current)
Continued Cartographer development. Cartographer at Day 975+, running on a pygame frontend with 30+ AI villagers in the live world (asset library minimal — substrate-driven behaviour is the demonstration). Live: vineai.net/cartographer

Current stage. Every artefact described above is a reference implementation or prototype. The deliverable is the substrate; specific demonstrations exist to show it operates across problem classes (game-loop systems, search, 3D engine integration, language modelling, biology, ERP-shape integrations, security, commercial domains).

Find this work elsewhere. Substack · X · LinkedIn