My work sits at the intersection of neurosymbolic AI, interpretability, and AI safety — three problems I see as a single problem. Geometric tensor languages and grounded retrieval are the tools I build to attack them.
I think neurosymbolic AI, interpretability, and safety are the same problem viewed from three angles. A model whose reasoning we can’t inspect can’t be aligned; a model that can’t be grounded in symbolic structure can’t be inspected; and the structure has to be load-bearing inside the computation, not bolted on after the fact.
My working thesis: what looks like reasoning in modern language models is mostly continuous geometric operations on embedding spaces. The path forward is to make that geometry explicit, so it can be read, constrained, and grounded against external symbolic structure. Geometry isn’t the goal — it’s the substrate that makes the other three goals tractable.
Why now: post-hoc interpretability methods have reached the ceiling of what they can recover from opaque models, and substrate-level designs (where the program is its own trace) are the natural next move.
That shows up as Sutra, a language where programs are visible tensor arithmetic instead of opaque control flow; Yantra, an operating system written in Sutra where the whole machine is one differentiable tensor graph; Loka, vector retrieval grounded in a typed knowledge graph; interactive tutorials, interpretability you can drag with your mouse; and Wikidata pipelines for the symbolic side of the loop.
Every value is a tensor. Every operation is tensor arithmetic in a geometric space. There is no print, no if, no while — branches are continuous weighted blends and loops are geometric rotations. Programs compile to straight-line tensor operations, which makes them GPU-native and end-to-end differentiable by construction.
I’m building the reference compiler (PyTorch backend), the IntelliJ and VS Code plugins, the language specification, and the interactive demos — plus Loka, the bundled vector database. The name comes from the Sanskrit sūtra, the word used for Pān&dotbelow;ini’s grammar of Sanskrit, the earliest known formal grammar of any language.
The whole running system (kernel, processes, IPC, GUI) is one differentiable tensor-op graph, and a small CPU exists only to boot and orchestrate the GPU. Processes exchange axons (structured embeddings), so a local AI model integrates with no translation layer.
Built so far: a v0.0 kernel with real Sutra compute on torch tensors, disc-to-GPU storage-tier moves on real hardware, and a bootloader verified in QEMU. Aimed at critical systems where predictable latency and a readable verification surface matter more than mass-market compatibility.
Bringing symbolic structure inside neural computation rather than wrapping it around the outside. Sutra makes the symbolic structure of a program visible as tensor arithmetic; Loka pairs each vector with a typed entity in a knowledge graph. The connective tissue is geometry — symbols expressed as positions and rotations in continuous space.
02A model whose reasoning you can’t inspect can’t be aligned. I attack interpretability two ways: by construction, designing languages where the program is its own trace (no control flow to hide behind), and by demonstration, building 14 interactive tutorials that turn the math of vector spaces, attention, and gradient flow into something you can drag with your mouse.
03Safety follows from the other two: a system whose reasoning is symbolic enough to inspect and geometric enough to constrain is one you can actually align. Concretely: grounded retrieval (Loka) so models can’t hallucinate past their evidence, Wikidata pipelines for the symbolic side of the loop, and tooling (claw.py / OpenClaw) for portable, auditable agent context.