Technical notes from experiments in language geometry, GPU inference, and agentic AI systems.
Work in progress. All numbers are from actual runs. Code linked where available.
Posts
-
rocmforge: GeoGraph Execution Engine and Branch Selection with a 0.5B Model
This post covers two things built in rocmforge over the past week: a graph-based CPU execution engine with temporal rollback, and a first working result using a local 0.5B model to select between branches.
-
Multi-Layer Graphs, Ricci Curvature, and a Hypothesis About How Computation Should Route
This post is about an idea, not a result. The experiment described here has not been run. The hypothesis may be wrong. I’m writing it down because the reasoning is worth making explicit before touching code.
-
Geometric-Only Attention: Linear Scaling from Sparse Neighborhoods
The previous posts documented a ceiling: every geometric attention variant converged to ~50.5 val perplexity on TinyStories, while a plain trigram MLP reached 32. Static geometry was the bottleneck.
-
Geometry as Substrate: What the Failing Results Are Telling Us
The previous post documented a series of negative results: PMI+SVD geometric positions don’t beat a trigram baseline, attention over geometry doesn’t beat a trigram baseline, RoPE doesn’t help, curvature weighting consistently hurts. Every experiment lost to two token IDs fed into a flat MLP.
-
rocmforge: Building an AMD GPU Inference Engine from Scratch
This is a prototype. It produces real throughput numbers on real hardware, it has a real GPU safety protocol because a real GPU page fault happened, and it implements a real stack of inference optimizations. It is also not finished, not stable, and not safe to run without caution. The CLAUDE.md for the project says: “Before ANY new GPU code: Acquire cross-process GPU lock → Run staged preflight → Use timeout-wrapped subprocess.” That rule exists because ignoring it caused a desktop freeze.
-
Training a Geometric Language Model in Pure Rust: First Results
The geometric decoder post described how a corpus-native graph can guide token decoding through Rodrigues rotation and curvature weighting. This post covers what happens when you connect that graph to a training loop and actually try to learn next-token prediction from it.
-
Envoy: The Coordination Server AI Coding Agents Were Missing
I run multiple AI coding agents in parallel. Claude Code sessions, Hermes agents, subagents spawning subagents. After a while I noticed something: none of them know the others exist. They overwrite each other’s files, repeat discoveries, and have no memory of what happened yesterday. There is no infrastructure for this. So I built one.
-
Envoy v0.2.0: Observability, Lock-Free Paths, and Bug Fixes
Three weeks after the initial release, envoy v0.2.0 is out. This isn’t a feature dump – it’s the result of running the server continuously and fixing the things that actually hurt. Three bugs from the original article got fixed, Prometheus metrics landed, and a performance improvement from another project turned out to transfer cleanly.
-
Atheneum: Persistent Memory for AI Coding Agents
Every AI coding session starts from zero. The assistant that helped you trace a bug yesterday has no memory of it today. You explain the same context again, re-answer the same questions, and watch it rediscover the same facts. The tools I’ve built over the last six months — magellan, llmgrep, mirage-analyzer — solve the code structure problem. They make the codebase queryable. But they don’t solve the session continuity problem. An agent still can’t carry decisions, discoveries, or hard-won debugging context from one session into the next.
-
SQLiteGraph: Why I Built One Embedded Library Instead of Four Services
I needed a graph database for a code intelligence project. The typical recommendation would have been Neo4j, or at minimum a graph library backed by something like PostgreSQL. But I was building a CLI tool that runs as a single process on a developer’s laptop. Pulling in a graph database server, a vector search service, a KV cache, and a pub/sub bus — plus connection management and process lifecycle for each — is the wrong architecture for that constraint.
-
Splice: Span-Safe Refactoring That Knows Your Codebase
Splice edits code using byte-accurate span replacements backed by graph algorithms. It replaces function bodies, renames symbols across files, deletes definitions with all their references, and generates machine-checkable refactoring proofs – all with AST validation and automatic rollback on failure.
-
Mirage: Building a Control-Flow Analysis Engine Without a Compiler Backend
Mirage analyzes control-flow graphs from Magellan databases. It enumerates execution paths, computes dominator trees, detects loops, finds dead code, identifies cycles, scores risk, and suggests refactorings – all without being a compiler pass or a language server. It reads what Magellan indexed and answers questions about program structure.
-
Magellan: Six Months of Building a Code Intelligence Indexer
I needed to understand codebases faster than
grepallows and more accurately than tossing files at a model. The answer wasn’t better prompts — it was a proper index. Not an IDE index (those are ephemeral), and not a search engine (those don’t understand structure). Something that records what symbols exist, where they’re defined, who calls whom, and how control flows — then makes all of that queryable from a CLI. -
llmgrep: The Query Layer That Grew With the Stack
In January 2026 I needed a way to search a Magellan database from the command line. Not an IDE plugin, not a language server – just a CLI tool that takes a query and returns structured JSON. Four and a half months later, that tool has 33 published versions, 9 search modes, 12 subcommands, and has evolved from a simple SQL wrapper into the primary query interface for the entire code intelligence stack.
-
Graph-Native Reasoning Experiments: What Worked, What Didn't, and Why
Over three months I ran a series of experiments testing whether graph-based reasoning – not transformers, not neural networks, but pure graph traversal with edge-weight reinforcement – can solve problems that normally require deep learning. The repo is at github.com/oldnordic/ai, 62K lines of Rust, 98 standalone experiment binaries, every result logged with the failures alongside the wins.
-
Ollivier-Ricci Curvature in a Corpus-Native Graph — No Training Required
Kuo et al. (Yale 2024) measured Ollivier-Ricci curvature in trained transformer embeddings (Llama 2, Gemma 2, DeepSeek) and found substantial negative mean curvature — the geometry of the embedding space is hyperbolic, not flat. Their interpretation: the structure emerges from training.
-
A Geometric Decoder for Language Graphs
This post is the decoder half of a larger experiment: can a language model decode by moving through a graph instead of comparing query/key vectors?
subscribe via RSS