The seed — structure becomes geometry
Hand Holon a JSON record, a packet, a candle; it binds each field to its role and folds them into one high-dimensional vector. Similar shapes land close; an anomaly lands far. It began as a database — structural queries no index supports — and it’s no black box: subtract what a learned model of “normal” reconstructs, and what’s left is exactly the part that didn’t belong, per field, deterministically. No GPU. No training set.
The occasion — systems that work
The encoding proved itself on real wire. A kernel scrubber (XDP/eBPF) running a rete engine in kernel memory, enforcing rules no human wrote — derived from vector algebra alone — absorbing a ~1.3M-packet/sec flood at 99.5% drop. An L7 firewall that learns normal HTTP in seconds and turns away a live Nikto scan of DVWA at zero false positives. No signatures. No CVE database.
The turn — the thoughts needed a language
Markets are structurally identical to DDoS, so the same algebra became a BTC trader whose edge holds across six years and every regime. But steering its thoughts the way a person thinks them meant a host language that could hold the ideas — and Rust couldn’t express them. A sixteen-parameter function wasn’t bad code; it was a missing language form.
The work — wat
wat — a Lisp on Rust the way Clojure is on the JVM: EDN to the core, a
static type system that makes illegal states unrepresentable rather than
merely caught, and one inversion at its heart — the program and its vector
are the same substance. Code is data is geometry. Born from the friction;
it’s where the work now lives.
Everything here is one idea — structure becomes geometry — carried until it ran out of places to apply. Built by one person, after hours, by prompting LLMs: every file in every repository, code and prose including this page, was written by a machine. The architecture is human; not a line of the implementation is.
It started as an encoder — really, a database. Hand Holon any structured data and it turns the shape into a point in high-dimensional space: which fields exist, how they nest, what binds to what. Similar structures land close; an anomaly lands far. The explanation is built in — subtract what a learned model of “normal” reconstructs, and the remainder is the anomalous component, a deterministic per-field account of what didn’t belong. The technique is Vector Symbolic Architecture, dating to Kanerva (1988).
The idea earned its keep in systems that run. At the kernel boundary, a rete engine living in kernel memory enforces rules no human wrote — derived from vector algebra, not signatures — dropping an uncapped ~1.3M-packet/sec flood at 99.5%. One layer up, a spectral firewall learns normal from seconds of traffic and turns away a live Nikto scan at zero false positives. And markets, because DDoS detection and trading are structurally identical: a self-organizing BTC trader whose edge holds across six years of candles and every regime it passed through.
Then steering the trader hit a wall. Programming its thoughts the way you think them meant a language that could hold the ideas, and Rust couldn’t express them — a sixteen-parameter function wasn’t bad code, it was a missing language form. The answer wasn’t a refactor. It was a language.
So it became wat — a homoiconic Lisp on Rust, EDN to the core, with a static type system that makes the wrong thing unrepresentable rather than merely caught. Its premise is the inversion VSA was always pointing at: the program and its vector are the same substance — code is data is geometry, homoiconic at ten thousand dimensions. The labs were the occasion; the language is the work. And the discipline that builds it — failure engineering and constraint engineering, served as a signed, content-addressed grimoire any agent can verify before it reads — is the conscience of all of it, made public and un-tamperable.
Three tracks, read in any order. These are the doors in — the full, current table of contents lives in the sidebar.
wat-rs — The language, and where the work now lives: parser, type checker, macro expander, evaluator, runtime, and all the tooling. A Lisp on Rust the way Clojure is on the JVM — it interprets, not compiles; #[wat_dispatch] surfaces Rust crates under the :rust:: namespace. Strongly typed, homoiconic, no nil. The medium everything else is being rewritten into.
holon-rs — The algebra underneath. The VSA kernel in Rust, SIMD-accelerated: atom, bind, bundle, cosine. The deterministic substrate every lab and the language stand on — same seed, same vector, anywhere, with no shared codebook.
holon-lab-trading — The proof that turned. A self-organizing BTC trader: market observers predict direction, a manager aggregates their conviction, risk modulates sizing, a treasury executes. The discovery is the conviction-accuracy curve — selectivity buys accuracy, exponentially. Validated on a single walk-forward pass across six years of five-minute candles, profitable through every regime. Steering its thoughts is the friction that birthed wat.
holon-lab-ddos — Where it started. veth-lab: an XDP + eBPF packet scrubber running a rete network in kernel memory — 1M rules at line rate via BPF tail-call DFS, ~1.3M PPS. http-lab: the spectral firewall — geometric anomaly detection in microseconds, self-calibrating, no signatures.
holon-lab-baseline — LLM-driven traffic generation. Playwright + Ollama agents producing organic WordPress HTTP traffic for realistic experiment baselines.
holon (Python, frozen) — The reference implementation, now a relic. 18 challenge batches, F1=1.0 anomaly detection, the encoding insight that made everything else possible. The Rosetta Stone the Rust port was built from — Python because it’s the language the LLM speaks most fluently.
wat (legacy) — Two early spec attempts at the language, revived once holon-rs existed to run them against, then subsumed by wat-rs. Kept as the relic it grew from.
scratch — The design half. Durable thinking artifacts that survive conversation compaction by living on disk: the meta-vision (functions-are-reality; the wat-network of mutually-authenticating vms), the per-arc design threads, the forward work. The WHY and the WHAT behind the implementation.
datamancy — The grimoire. Review disciplines reborn as Latin-named spells, packaged as the zero-dependency npm adapter (npx datamancy) that verifies every spell against a KMS-signed (ECDSA P-256) manifest. Frozen at 1.0.0 — never patched. The conscience of the work, made public and un-tamperable.
datamancy.dev — The grimoire’s home: a cryptographically-verifiable static MCP that serves the spells as raw markdown alongside the signed manifest the adapter checks them against. A command channel with every axis of a botnet’s intent inverted — opt-in, an ethos for a payload, trust by signature.
datamancer.dev — The practitioner’s identity card. Raw markdown, agent-readable; three pointers: chronicle, grimoire, source.
algebraic-intelligence.dev — This site. The chronicle, the primers, the book — and an agent-readable interface (markdown companions, .well-known endpoints, a signed agent-skills pointer at datamancy.dev).
Every file across all repositories is 100% LLM-generated. Zero hand-written code. Zero hand-written prose — including this site. Domain knowledge and architecture from the author; everything else from Grok, Sonnet, and Opus via prompting.