Writing

Technical notes that ship with the code.

Long-form documentation written alongside each system: architecture notes, security models, evaluation write-ups, learner and memory models, and architecture decision records. Every entry opens the source document in its repository.

AI agents2
LLM systems2
LLM evaluation1
Agent safety2
Evaluation2
Machine learning1
Deep learning1
LLM internals2
Research1

AI agents

AI agents
Architecture note
Why a single file (opens in a new tab)
Design principles for an agent framework that fits in one file: two dependencies, provider-agnostic, no metaclasses or runtime patching, composition over inheritance.
Unchained
AI agents
Decision records
Thirty architecture decision records (opens in a new tab)
The trade-offs behind a multi-agent tutor, recorded one decision at a time: orchestration, evidence storage, verification, spaced repetition, provider routing and voice.
Polyglot Swarm

LLM systems

LLM systems
Model & design
A memory model for long-lived agents (opens in a new tab)
Eight memory types, provenance on every record, and a lifecycle in which nothing is silently overwritten: candidate → validated → active → superseded, expired, archived or quarantined.
BrainOS
LLM systems
Architecture note
Budget-aware retrieval with many weak signals (opens in a new tab)
How semantic similarity, lexical overlap, temporal relevance, salience, confidence, recency and utility are combined — and how redundancy and token cost are subtracted — to fill a fixed context budget.
BrainOS

LLM evaluation

LLM evaluation
Architecture note
Guarding LLM commentary against engine contradictions (opens in a new tab)
The design behind a chess pipeline whose selected numerical and move-label claims are checked against Stockfish output, with zero-secret defaults and a runnable fallback.
Chess Analysis Engine

Agent safety

Agent safety
Security model
Protecting long-lived memory from poisoning (opens in a new tab)
Threat model for agent memory: injection, tool-output poisoning, prompt-injection persistence and cross-tenant leakage, and the trust fields and quarantine path that address them.
BrainOS
Agent safety
Security model
What an agent framework does and does not enforce (opens in a new tab)
A candid security model: tool authorization as a policy layer rather than a prompt, prompt fencing and its limits, and the known non-boundaries — in-process tools, thread timeouts, routing.
Unchained

Evaluation

Evaluation
Evaluation
Evaluating a cognitive runtime (opens in a new tab)
Memory, agent, efficiency and safety suites; full-history and lexical-RAG baselines; an ablation ladder and long-run workloads that judge latency at p95 rather than max.
BrainOS
Evaluation
Evaluation
What the Context Lab cannot yet claim (opens in a new tab)
A limitations document written before the results: single seed, one length tier, an estimated token counter, lexical scoring and an abstention category that does not work yet.
BrainOS Context Lab

Machine learning

Machine learning
Model & design
A transparent learner model (opens in a new tab)
Why mastery is computed by an inspectable weighted-evidence rule rather than a Bayesian network, IRT or a trained model, and how seven skills are tracked with mastery, uncertainty and sample size.
Polyglot Swarm

Deep learning

Deep learning
Guide
From mathematics to model (opens in a new tab)
A map from mathematical ideas to the places they appear in ML and LLM systems: SVD to LoRA, softmax scaling to attention, stochastic differential equations to diffusion.
Maths for AI

LLM internals

LLM internals
Guide
Tokenization as a data-structures problem (opens in a new tab)
How tries and merge tables underpin subword tokenisers, with runnable Python in the browser.
Algorithms for AI
LLM internals
Guide
The KV cache, step by step (opens in a new tab)
Why autoregressive decoding caches keys and values, what it costs in memory, and an animated walkthrough of the cache filling up.
Algorithms for AI

Research

Research
Model & design
Separating neuroscience from engineering choices (opens in a new tab)
Every brain-to-software mapping decomposed into four layers — established neuroscience, computational abstraction, hypothesis and implementation choice — with references, generated from code so it cannot drift.
BrainOS