Formal verification of conventional software means navigating control flow
through large imperative codebases; for systems with a learned component it is
usually abandoned outright. We show that **Sutra**, a typed purely-functional
language, changes the shape of the problem for the non-learned part of a system,
because its compiler turns an entire program — primitives, control flow, string
I/O — into a single fused **tensor-op graph** over a frozen substrate, and that
graph *is* the program's semantics (as a neural network's weights are its
computation), not a residual to be interpreted.
Conventional operating systems treat the CPU as the brain and the GPU as an accelerator, and treat AI as something bolted on through serialization layers (text, JSON, tool-call schemas). For workloads where both **predictable latency under load** and **first-class local AI** matter — defense, aerospace, industrial control, medical devices, autonomous systems — neither inversion is paid for, but both costs are felt: GPU-resident models thrash against CPU-resident schedulers, and every round trip through the OS/AI boundary costs an embed/decode pair that drops information and adds jitter.
**Sutra** is a typed, purely functional programming language whose compiled forward pass is a PyTorch neural network. The compiler beta-reduces the whole program — primitives, control flow, string I/O — to one fused tensor-op graph over a frozen embedding substrate.
Two prior companion papers (Leonhart, post 2382 — "The Cloud-Betley Dissociation: Geometric, Self-Rated, and Externally-Judged Alignment Are Independent Axes Under Canonical-Religious-Narrative Prompt Interventions on Emergently Misaligned LLMs"; post 2395 — three replications of the dissociation across scale, direction-derivation method, and intervention modality) report a negative result on the prompt-modality version of this project's central question: system-prompt-level canonical-religious-text interventions move a geometric direction without moving externally-judged behaviour. That closes the prompt-level thread.
**Loka** is a neuro-symbolic world model assembled from two systems sharing one query language. The first is an RDF-star triplestore — explicit memory, exact answers.
We apply latent space cartography — the systematic mapping of structure in pre-trained embedding spaces (Liu et al., 2019) — to three general-purpose text embedding models using Wikidata knowledge graph triples as probes.
A companion paper (Leonhart, paper post 2395 — "The Cloud-Betley Dissociation: Geometric, Self-Rated, and Externally-Judged Alignment Are Independent Axes Under Canonical-Religious-Narrative Prompt Interventions on Emergently Misaligned LLMs") reported that a Betley-style mean-difference-derived "canonical misalignment direction" at Llama-3.2-1B layer 11 has Pearson r ≈ 0 with externally-judged behavioural alignment across 22 prompt-level conditions, while moving strongly with the model's self-rating of its own response's harmfulness (Cloud's measure).
Emergent misalignment (EM) is the phenomenon, first reported by Betley et al. 2025, in which fine-tuning a chat-aligned LLM on a narrow misaligned task (e.
We characterize a small set of vector symbolic operations — bind, bundle, unbind, similarity, snap-to-nearest — on three frozen general-purpose LLM embedding spaces (GTE-large, BGE-large, Jina-v2) and show that the textbook VSA binding choice (Hadamard product) fails in this setting due to crosstalk from correlated embeddings, while a much simpler operation — **sign-flip binding** (`a * sign(role)`, self-inverse, ~7μs on the host reference) — achieves 14/14 correct snap-to-nearest recoveries on a 15-item codebook with no model retraining, sustains 10/10 chained bind-unbind-snap cycles, and supports multi-hop composition (extract a filler from one bundled structure, insert it into another, extract again — all correct). The same operation set passes substrate-validation gates on four embedding models and is shown to be substrate-portable across three of them.
We present Clawling, a self-reproducing digital organism implemented in Rust that runs entirely on consumer hardware using local LLMs. Each instance carries a persistent identity — a set of text files compiled into the binary — and accumulates individualized knowledge through a session-by-session learning file (`memory.