Blog Series

Series

• AI Tools (5)
• Bucket List (3)
• Deepseek Papers (3)
• Dogfooding (1)
• Down the Rabbit-Hole (5)
• Embedded (3)
• Five ML Concepts (30)
• General Technology (3)
• How AI Learns (7)
• Machine Learning (8)
• Machine Learning Frontier (5)
• Multi-Hop Reasoning (2)
• Personal Software (9)
• Sharpen the Saw Sundays (9)
• Small Models, Big Brains (6)
• Throwback Thursday (10)
• Towards Continuous LLM Learning (2)

Multi-part blog post series, organized by topic.

AI Tools

• Part 1: AI Tools #1: XSkill --- A Memory Layer for Multimodal Agents

  584 words • 3 min read • Abstract

  XSkill gives multimodal agents persistent memory---Skills for structured workflows and Experiences for tactical lessons---improving tool use by 2-6 points across five benchmarks without retraining.
• Part 2: AI Tools #2: AgentRail Mid-Saga --- Insert, Reorder, Reopen, Recover

  1608 words • 9 min read • Abstract

  Sagas assume linear plans. Daily use across parallel repos assumes surprises. The April AgentRail features --- insert/reorder/reopen, audit/snapshot, maintenance mode --- are what you only design after you actually live with the tool.
• Part 3: AI Tools #3: sw-checklist --- Reining In AI Coding Agents With a Code-Metrics Ratchet

  1695 words • 9 min read • Abstract

  sw-checklist is a personal-software Rust CLI I wrote to rein in AI coding agents: function/file/module/crate size limits enforced as warnings and failures. The post threads Brooks (essential vs accidental complexity) and Hickey (simple vs easy, complect vs decomplect) through that tool. The metrics are an accidental cost, but they pay rent --- AI agents that started out reacting to violations eventually anticipate them, and the long-run code stays focused on essential complexity. The metaphor for tech debt is a ratchet: clicks back are sometimes allowed, but the wrench only turns one way.
• Part 4: AI Tools #4: Pi --- The Minimal Agent That Stays Out of the Way

  1500 words • 8 min read • Abstract

  Pi is interesting because it does not try to become an IDE, platform, or operating system. After using it with a local Ollama model and one small package, the useful slant is simpler: a minimal agent loop uses the model's available context efficiently, and the lack of ceremony is the feature.
• Part 5: AI Tools #5: nono --- Sandboxing Pi Without Breaking the Loop

  1699 words • 9 min read • Abstract

  nono is attractive because AI coding agents need real boundaries, but making nono, Pi, Ollama, and local models work together took iteration. The usable shape was not to wrap every layer. It was to sandbox Pi, let Pi call Ollama, and then find models that actually act instead of merely describing what they plan to do.

Bucket List

• Part 1: Bucket List #1: Things I've Always Wanted to Build

  1003 words • 6 min read • Abstract

  A lifelong list of technical things I always wanted to learn and build---too busy during my career, too hard before AI. Now retired, I'm working through them for fun, no deadlines. This is the introduction to the list.
• Part 2: Bucket List #2: A Landing Page for Software Tools

  1101 words • 6 min read • Abstract

  Two weeks of vibe-coding with agentrail-rs produced a landing page for the COR24 Software Tools ecosystem---a portfolio of bucket list items that are actually getting done: a Lisp with garbage collection, a p-code VM, two programming languages, a monitor, an editor, and more.
• Part 3: Bucket List #3: 3D Source Code, Five New Languages, and Visible Compilers

  2876 words • 15 min read • Abstract

  Three threads winding through the next chunk of the bucket list. First, source code in three dimensions: punch cards were 1D, screens are 2D, DiscoveryOne projects glyphs at (x, y, z) onto seven semantic facets. Second, five programming languages of my own currently in flight --- PL/SW, SWS, sw-MLPL, Tuplet, and DiscoveryOne --- each picking a different point on the build-axis / run-axis space. Third, the missing tool category that would tie all the language work together: educational visualizers that let you *watch* a compiler run --- step through a lexer, animate a parser, observe register allocation, see a heap fill and a garbage collector reclaim it, watch a JIT tier up. Most CS students never see any of this. They read about it. I want to build the surface that lets them watch.

Deepseek Papers

• Part 1: Deepseek Papers (1/3): mHC - Training Stability at Any Depth

  765 words • 4 min read • Abstract

  Implementing Deepseek's mHC (Manifold-Constrained Hyper-Connections) paper. Using Sinkhorn-Knopp iteration to create doubly-stochastic matrices, mHC maintains training stability at 48 layers where standard hyper-connections explode. Cross-platform validation on Apple Silicon and NVIDIA.
• Part 2: Deepseek Papers (2/3): Engram - Conditional Memory for Transformers

  710 words • 4 min read • Abstract

  Implementing Deepseek's Engram paper on conditional memory. Instead of recomputing common patterns through O(n^2) attention, Engram provides O(1) lookup for cached results. Our LoRA-based behavioral approximation achieves 58% loss reduction in 10 seconds.
• Part 3: Deepseek Papers (3/3): Engram Revisited - From Emulation to Implementation

  1038 words • 6 min read • Abstract

  From behavioral emulation to real implementation: integrating hash-based Engram memory with HuggingFace models. The gating mechanism is critical---it learns when to trust memory lookup and when hash collisions would add noise. Engram excels at exact-match retrieval, not generalization.

Dogfooding

• Part 1: Dogfooding #1: YAGNI Until You Do --- A Pascal P-Code Bump Allocator Grows a Free List

  1527 words • 8 min read • Abstract

  First post in a new Dogfooding series. The Pascal p-code VM shipped with a bump allocator and a no-op free --- enough for small demos, intentionally not more. Then OCaml-in-Pascal (used to write the Tuplet lexer/parser) ran out of heap mid-parse, even after re-doubling the heap twice. YAGNI worked right up until I needed it. This post is about that crossing-over moment: what the bump allocator bought, what it cost, and what reclaim looks like when it finally has to ship.

Down the Rabbit-Hole

• Part 1: Rabbit-hole #1: Poor Man's Rust-to-Unsupported-ISA Translator

  2797 words • 14 min read • Abstract

  How to compile Rust for a CPU that rustc doesn't support---by targeting one it does. Uses MSP430 as a 16-bit stepping stone to generate code for the 24-bit COR24 RISC architecture, then traces the full pipeline from source to registers.
• Part 2: Rabbit-hole #2: FORTH --- FIND and the Cost of a Name

  2227 words • 12 min read • Abstract

  A rabbit hole on FORTH, following the phase-4 direction set out in the self-hosting spectrum post. Dictionary lookup is the price Forth pays for readability: this post walks through what FIND does, how the all-asm kernel made it fast with a 2-round XMX hash and a 1-entry lookaside cache, and why phase 4 (forth-from-forth) is dropping the whole subsystem now that FIND lives in high-level Forth.
• Part 3: Rabbit-hole #3: FORTH --- Life After Hashing

  1951 words • 10 min read • Abstract

  Phase 4 of the COR24 Forth ships without the XMX hash. What replaces it? A layered set of cheap optimizations --- numeric fast path, recent-hit cache, hot-token cache --- that target the interactive hot path without rebuilding the hash subsystem. Plus the instrumentation you need to know which words to actually cache.
• Part 4: Rabbit-hole #4: FORTH --- Dictionary Compaction and Specialized Images

  2066 words • 11 min read • Abstract

  After optimizing FIND (rabbit-hole 2 and 3), the next move is to eliminate FIND entirely for deployment. This post walks the jump from dev image to runtime image: pruning shadowed redefinitions, dropping the compiler/REPL/instrumentation for production builds, and the pointer-rewriting work that actually makes compaction safe. Frames the whole thing as a Forth composer — one small core plus pluggable feature modules plus target profiles.
• Part 5: Rabbit-hole #5: FORTH --- Retargetable Codegen and the Forward-Reference Problem

  1278 words • 7 min read • Abstract

  After dictionary compaction turns one Forth source tree into different vertical profiles, the next rabbit trail goes horizontal: how does the same self-hosted Forth compiler target COR24, WASM, RV32I, or S/360 without forking the language, and how do forward references and mutually recursive words survive that split?

Embedded

• Part 1: Embedded #1: BMP280 Driver --- From Prototype to Patent Proof-of-Concept

  1192 words • 6 min read • Abstract

  A no_std Rust driver for the BMP280 pressure sensor, extended to support dozens of sensors via I2C multiplexers for a patent proof-of-concept. The journey from single-sensor to multi-mux arrays, and the eventual upgrade to BMP581.
• Part 2: Embedded #2: COR24-RS --- Learn Assembly in Your Browser

  1943 words • 10 min read • Abstract

  A Rust-based browser emulator for the COR24 instruction set architecture. Three tabs---Assembly, C, Rust---all running on the same COR24 CPU in your browser. Includes interactive tutorials, coding challenges, animated tours, self-test mode, realistic UART timing, and a complete ISA reference. No installation required.
• Part 3: Embedded #3: How Much of Forth Can Be Forth? A Kernel Self-Hosting Spectrum

  6918 words • 35 min read • Abstract

  How much of a Forth kernel can be written in Forth instead of assembly? Four points along that spectrum, from a 3000-line all-asm kernel to a Forth-hosted cross-compiler that emits its own .s file. This post walks through phase 1 (all-asm), phase 2 (forth-in-forth, shipped with XMX-hashed FIND and a 1-entry lookaside cache), phase 3 (forth-on-forthish, first two subsets shipping — ,DOCOL plus Forth : and ;), and phase 4 (forth-from-forth, future). Plus the performance work — hashing, cache, adaptive web pump-loop, build-time snapshot.

Five ML Concepts

• Part 1: Five ML Concepts - #1

  416 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Backpropagation (learning by flowing error backward), Transformers (attention over all tokens), Mamba (linear-time sequence modeling), Hallucination (confident nonsense), and Embeddings (meaning as coordinates).
• Part 2: Five ML Concepts - #2

  451 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Gradient Descent (walk downhill to minimize error), Attention (focus on what matters), DPO (align from preference pairs), Learning Rate (step size tradeoff), Temperature (dial between predictable and creative).
• Part 3: Five ML Concepts - #3

  529 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Loss Function (how far off predictions are), Overfitting (memorizing vs learning), Fine-tuning (specializing pre-trained models), LoRA (efficient adaptation with small matrices), Tokenization (breaking text into digestible pieces).
• Part 4: Five ML Concepts - #4

  458 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Activation Functions (introduce nonlinearity), Transfer Learning (reuse knowledge across tasks), VLM (joint image-text understanding), Adam (adaptive learning rates), Superposition (many concepts in overlapping representations).
• Part 5: Five ML Concepts - #5

  498 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Perceptron (single linear unit ancestor), Pre-training (learn general patterns first), Speculative Decoding (draft fast, verify in parallel), In-Context Learning (adapt from prompt examples), Latent Space (internal representations where similar things cluster).
• Part 6: Five ML Concepts - #6

  496 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Regularization (constraints to prevent overfitting), BERT (bidirectional masked language modeling), RoPE (position via rotation in attention), Prompting (craft inputs to steer outputs), Positional Encoding (tell model where tokens are).
• Part 7: Five ML Concepts - #7

  474 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Cross-Validation (rotate held-out data), GPT (predict next token at scale), GQA (shared keys/values for efficiency), Context Window (how much the model sees), Self-Attention (each token attends to all others).
• Part 8: Five ML Concepts - #8

  482 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Bias-Variance Tradeoff (balance under/overfitting), Diffusion (generate by learning to denoise), KV Cache (store past keys/values), Mixed Precision (lower precision for speed), MLA (compress attention into latent space).
• Part 9: Five ML Concepts - #9

  475 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Dropout (random disabling prevents overfitting), RLHF (learn from human preferences), Inference (using trained models), Quantization (lower precision for efficiency), Flash Attention (block-wise for memory savings).
• Part 10: Five ML Concepts - #10

  504 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: CNN (sliding filters for image features), Encoder-Decoder (compress then generate), RAG (retrieve context before generating), Few-shot Learning (learn from prompt examples), Distillation (small student mimics large teacher).
• Part 11: Five ML Concepts - #11

  508 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: RNN (sequential processing with memory), Chain of Thought (step-by-step reasoning), Softmax (scores to probabilities), MoE (route inputs to specialists), Distribution Shift (training vs deployment mismatch).
• Part 12: Five ML Concepts - #12

  493 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Precision vs Recall (correct positives vs finding all), OOD Inputs (data unlike training), Batch Size (examples per update), Inductive Bias (built-in assumptions), Latency vs Throughput (speed vs capacity).
• Part 13: Five ML Concepts - #13

  453 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Calibration (predicted probabilities match outcomes), Shortcut Learning (exploiting spurious patterns), Early Stopping (halt when validation plateaus), Universal Approximation (NNs can fit any function), Checkpointing (save model state).
• Part 14: Five ML Concepts - #14

  453 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: ROC/AUC (performance across thresholds), Spurious Correlations (coincidental patterns), Gradient Clipping (limit gradients for stability), Loss Landscapes (error surface over parameters), Cold Start (no history for new users).
• Part 15: Five ML Concepts - #15

  475 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Perplexity (how surprised by data), Catastrophic Forgetting (new learning erases old), Weight Initialization (starting values matter), Curse of Dimensionality (high-D makes data sparse), Monitoring (track performance and drift).
• Part 16: Five ML Concepts - #16

  473 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Train/Val/Test Split (separate data roles), Overconfidence (high probability wrong predictions), Batch Normalization (stable training), Optimization vs Generalization (low train loss doesn't mean good test), A/B Testing (compare with experiments).
• Part 17: Five ML Concepts - #17

  477 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Benchmark Leakage (test data contamination), Concept vs Data Drift (changed relationships vs inputs), Weight Decay (L2 penalty for simplicity), Scaling Laws (predictable performance growth), Shadow Deployment (test alongside production).
• Part 18: Five ML Concepts - #18

  449 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Preference Learning (train from comparisons), Ensembling (combine models for robustness), ML Fragility (breaks on distribution shift), Epoch (one pass through data), Cost vs Quality (bigger isn't always better).
• Part 19: Five ML Concepts - #19

  456 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Autoencoders (compress and reconstruct), Correlation vs Causation (co-occurrence isn't cause), Curriculum Learning (easy to hard), Failure Analysis (categorize errors), Covariate Shift (new inputs, same task).
• Part 20: Five ML Concepts - #20

  461 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: VAEs (generative with structured latents), Uncertainty Estimation (know when you don't know), Interpretability (distributed representations resist explanation), Gradient Noise (mini-batch variation), Human-in-the-Loop (human oversight for critical decisions).
• Part 21: Five ML Concepts - #21

  452 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Prompt Injection (malicious instructions overriding AI behavior), Jailbreaks (bypassing safety constraints), GRU (gated recurrent units for sequences), Planning vs Prediction (action evaluation vs forecasting), Production Rollbacks (reverting to stable model versions).
• Part 22: Five ML Concepts - #22

  477 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: RSFT (rejection sampling fine-tuning with filtered outputs), Model Steerability (adjusting behavior at inference time), LSTM (long short-term memory for sequences), Why More Data Beats Better Models (data scale trumps architecture tweaks), System Reliability vs Model Quality (balancing accuracy with uptime).
• Part 23: Five ML Concepts - #23

  445 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Emergent Behavior (capabilities appearing at scale), Tool Use (AI calling external tools), Loss Surface Sharpness (flatter minima generalize better), Learning Rate Schedules (adjusting learning rate during training), Canary Deployment (gradually rolling out new models safely).
• Part 24: Five ML Concepts - #24

  431 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Warmup (gradually increasing learning rate at start), Data Leakage (training on unavailable deployment info), Mode Collapse (limited generative output variety), Blue/Green Deployment (switching between parallel production environments), Reward Hacking (exploiting reward function flaws).
• Part 25: Five ML Concepts - #25

  411 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Label Smoothing (softening targets to reduce overconfidence), Miscalibration (confidence not matching accuracy), Representation Learning (automatically learning useful features), Adversarial Examples (inputs crafted to cause errors), Double Descent (test error decreasing twice with model size).
• Part 26: Five ML Concepts - #26

  429 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Data Augmentation (expanding training data with transformations), Caching Strategies (reducing latency by reusing computation), Constitutional AI (training models to follow explicit principles), Goodhart's Law (optimizing metrics distorts objectives), Manifold Hypothesis (data lies on lower-dimensional structures).
• Part 27: Five ML Concepts - #27

  424 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Elastic Weight Consolidation (protecting important parameters during new task learning), Replay Buffers (mixing past examples to prevent forgetting), Parameter Routing (activating task-specific parameter subsets), Memory-Augmented Networks (external memory modules for neural networks), Model Editing (targeted weight updates without full retraining).
• Part 28: Five ML Concepts - #28

  448 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Lottery Ticket Hypothesis (small winning subnetworks within large models), Sparse Activation (using only part of a model per input), Conditional Computation (dynamically routing inputs for efficiency), Inference Parallelism (distributing inference across devices), Compute Optimality (balancing model size, data, and compute).
• Part 29: Five ML Concepts - #29

  462 words • 3 min read • Abstract

  Five ML concepts in under 30 seconds each: Neural Collapse (late-stage geometric convergence of class representations), Grokking (sudden generalization after prolonged memorization), SAM (optimizing for flat loss regions under perturbations), Mechanistic Interpretability (analyzing internal circuits of neural networks), Self-Training Instability (feedback loops that amplify errors in self-generated data).
• Part 30: Five ML Concepts - #30: The Journey So Far

  3559 words • 18 min read • Abstract

  Episode 30 marks a milestone: 145 machine learning concepts covered across 30 episodes. From backpropagation to scaling laws, dropout to distribution shift, RAG to reward hacking. This retrospective celebrates the journey and announces what's next: Frontier ML Thinking—one concept, two minutes, deeper implications.

General Technology

• Part 1: MCP: Teaching Claude to Play (and Trash Talk)

  666 words • 4 min read • Abstract

  Teaching Claude to play tic-tac-toe and trash talk using Model Context Protocol (MCP). A Rust server exposes 6 tools via JSON-RPC over stdio, proving MCP standardizes AI tool integration across any compatible language model.
• Part 2: JSON et al: A Deep Dive into Data Serialization Formats

  2244 words • 12 min read • Abstract

  JSON is everywhere, but it's not the only option. This post explores data formats beyond basic JSON—JSONL for streaming, JSONB for fast queries, Protocol Buffers for compact wire formats, YAML/TOML for human editing, and TOON for LLM efficiency. Each has trade-offs: pick two of readability, compactness, or speed.
• Part 3: Lucy 20%: Upgrading My Home AI Cluster

  905 words • 5 min read • Abstract

  Expanding my home AI cluster from 10% to 20% brain power with a new X99 motherboard and RTX 3090. Adding VoxCPM voice cloning, FLUX text-to-image, and Wan 2.2 text-to-video capabilities.

How AI Learns

• Part 1: How AI Learns Part 1: The Many Meanings of Learning

  597 words • 3 min read • Abstract

  When people say 'AI learned something,' they usually mean one of four very different things. Understanding these time scales---from milliseconds to years---is essential for building AI systems that improve safely over time.
• Part 2: How AI Learns Part 2: Catastrophic Forgetting vs Context Rot

  646 words • 4 min read • Abstract

  Two fundamentally different failure modes plague AI systems. Catastrophic forgetting destroys old knowledge when learning new skills. Context rot loses early instructions in long conversations. Different problems, different solutions.
• Part 3: How AI Learns Part 3: Weight-Based Learning

  654 words • 4 min read • Abstract

  Weight-based learning modifies the neural network itself. Pretraining, fine-tuning, LoRA, alignment methods, distillation---each changes the brain permanently. Slow to change, but forms the stable core.
• Part 4: How AI Learns Part 4: Memory-Based Learning

  632 words • 4 min read • Abstract

  Modern AI systems increasingly rely on external memory. RAG, CAG, and Engram-style modules shift 'learning' away from weights. The brain stays stable. The notebook grows.
• Part 5: How AI Learns Part 5: Context Engineering & Recursive Reasoning

  636 words • 4 min read • Abstract

  Large context windows are not a complete solution. As context grows, attention dilutes and instructions drift. Recursive Language Models treat context as a dynamic environment, rebuilding focus each step instead of dragging everything forward.
• Part 6: How AI Learns Part 6: Toward Continuous Learning

  696 words • 4 min read • Abstract

  Continuous learning aims to absorb new information and skills over time without losing old capabilities. The key: learn often in memory, consolidate carefully in weights. Periodic consolidation, not constant updates.
• Part 7: How AI Learns Part 7: Designing a Continuous Learning Agent

  899 words • 5 min read • Abstract

  A robust architecture: core model (rarely updated) + adapters (modular skills) + external memory (facts) + context manager (RLM-style) + logging and evaluation loop. Errors feed into memory first. Only recurring, validated improvements reach adapters.

Machine Learning

• Part 1: Solving Sparse Rewards with Many Eyes

  1478 words • 8 min read • Abstract

  Single explorer: 0% success. Five explorers: 60% success. Sparse rewards are an information problem, not a compute problem. Using multiple scouts with different exploration strategies, we gather diverse discoveries that benefit a shared learner.
• Part 2: DyTopo: Dynamic Topology for Multi-Agent AI

  786 words • 4 min read • Abstract

  When multiple AI agents work together, fixed communication patterns fail at scale. DyTopo rebuilds the graph each round based on semantic similarity between what agents need and what they can offer, preventing context explosion while enabling adaptive collaboration.
• Part 3: RLM: Recursive Language Models for Massive Context

  1000 words • 5 min read • Abstract

  When data won't fit in a context window, RLM expands the workspace instead. The MIT paper achieves 87-91% accuracy where standard prompting scores 0%. My Rust implementation provides four capability levels from DSL commands to WASM sandboxing to LLM delegation.
• Part 4: Neural-Net-RS: An Educational Neural Network Platform

  1053 words • 6 min read • Abstract

  Personal Software for education: a neural network platform where every step is visible---no framework magic. CLI with progress bars, web UI with real-time loss charts, WASM for browser execution. Built via Vibe Coding to watch XOR training reveal why hidden layers matter.
• Part 5: In-Context Learning Revisited: From Mystery to Engineering

  648 words • 4 min read • Abstract

  ICL evolved from emergent surprise (2020) to mechanistic understanding (2022) to engineered capability (2026). Transformers implement implicit gradient descent during inference---they learn without weight updates. The frontier: models learning from their own feedback. Not magic. Meta-learning in plain sight.
• Part 6: Many-Eyes Learning: Intrinsic Rewards and Diversity

  1398 words • 7 min read • Abstract

  Expanding many-eyes learning with intrinsic rewards and a new web visualization. CuriousScout uses count-based novelty, OptimisticScout uses optimistic initialization. The key trade-off: diversity helps during exploration, but once Q-values converge, all scouts should follow the same optimal policy. Strategy quality matters more than diversity in simple environments.
• Part 7: Large-Language-Monkeys: Scaling Inference, Not Models

  2009 words • 11 min read • Abstract

  Brown et al. (2024) show that repeatedly sampling a small model --- and letting an automatic verifier pick the best candidate --- can beat single-shot frontier models at a fraction of the cost. DeepSeek-Coder-V2-Instruct jumps from 15.9% to 56% on SWE-bench Lite with 250 samples. Coverage scales log-linearly across four orders of magnitude. This post walks the paper, reproduces the shape of the result on an 8B vs 70B binary_search demo, and asks what changes when inference itself is the scaling axis.
• Part 8: Energy-Based Learning: From Hopfield Networks to JEPA

  1136 words • 6 min read • Abstract

  Energy-based learning frames intelligence as making compatible configurations low energy and incompatible ones high energy. Hopfield networks made memory an energy landscape, Boltzmann machines made that landscape stochastic and learnable, and JEPA carries the idea forward into representation-space prediction.

Machine Learning Frontier

• Part 1: ML Frontier #01: Neural Collapse

  736 words • 4 min read • Abstract

  Why do deep networks converge to elegant geometric structures? Neural collapse explains: during late training, class representations form a symmetric simplex structure. Research from 2024-2025 proves this is globally optimal in deep transformers and ResNets.
• Part 2: ML Frontier #02: In-Context Reinforcement Learning

  823 words • 5 min read • Abstract

  Transformers can learn reinforcement learning policies from trajectory examples in the prompt---no weight updates, no gradient descent. ICRL turns agents from amnesiacs into learners by injecting successful execution traces into context.
• Part 3: ML Frontier #03: Structure Beats Scale --- Knowledge Graphs and Domain-Specific Superintelligence

  707 words • 4 min read • Abstract

  What if scaling AI didn't require bigger models---but better structure? Princeton research proposes Domain-Specific Superintelligence: smaller expert models grounded in Knowledge Graphs, where the graph itself serves as both curriculum and reward model for verifiable multi-hop reasoning.
• Part 4: ML Frontier #04: Is Chain of Thought Real?

  1201 words • 7 min read • Abstract

  Chain of Thought prompting transformed AI reasoning in 2022. By 2026, the frontier has shifted from making CoT better to asking whether it reflects real reasoning at all---and when step-by-step thinking helps versus hurts.
• Part 5: ML Frontier #05: Grokking --- Delayed Generalization

  835 words • 5 min read • Abstract

  Train a small network past the point of zero training loss and sometimes --- thousands of steps later --- test accuracy suddenly jumps from random to near perfect. The model didn't just memorize; it discovered the rule. This is grokking, and the research explaining it reframes generalization as a phase transition.

Multi-Hop Reasoning

• Part 1: Multi-Hop Reasoning (1/2): Training Wheels for Small LLMs

  697 words • 4 min read • Abstract

  A 135M parameter model goes from 0% to 75% accuracy in 5 minutes. Using knowledge graph-guided training with rejection sampling, we teach multi-hop reasoning with scaffolding during training, then remove it at inference.
• Part 2: Multi-Hop Reasoning (2/2): The Distribution Trap

  801 words • 5 min read • Abstract

  RSFT on easy examples made performance worse---27% vs 37% SFT baseline. Training distribution must match evaluation distribution. Easy examples teach shortcuts that fail on hard problems. The fix is one flag change.

Personal Software

• Part 1: Cat Finder: Personal Software via Vibe Coding

  919 words • 5 min read • Abstract

  Personal Software via Vibe Coding: I needed to find cat photos scattered across my system. Instead of cloud services or app stores, I described what I wanted to Claude Code and got a working Rust CLI tool using YOLOv8 and ONNX Runtime. Privacy-first, locally-run, and mine to modify.
• Part 2: midi-cli-rs: Music Generation for AI Coding Agents

  1043 words • 6 min read • Abstract

  Personal Software via Vibe Coding: a music tool for AI agents. midi-cli-rs provides mood presets (suspense, upbeat, calm, jazz) so agents can generate complete audio compositions from simple commands. No music theory required.
• Part 3: midi-cli-rs: Extending with Custom Mood Packs

  1337 words • 7 min read • Abstract

  Personal Software grows. midi-cli-rs now supports custom mood packs---TOML files that extend built-in moods with your own musical variations. No Rust required. Define tempo, key, intensity, and let the generators handle the rest.
• Part 4: music-pipe-rs: Unix Pipelines for MIDI Composition

  1155 words • 6 min read • Abstract

  Personal Software continues. music-pipe-rs takes the Unix philosophy to MIDI composition---small tools connected by pipes. Start with a seed, generate motifs, transform, visualize, convert to MIDI. Deterministic output from a single seed at the pipeline head.
• Part 5: music-pipe-rs: Web Demo and Multi-Instrument Arrangements

  685 words • 4 min read • Abstract

  Continuing the music-pipe-rs story: a web demo with Bach and Baroque arrangements, the seq command for explicit note sequences, and GarageBand integration. Plus the generative music resources that inspired this project.
• Part 6: rank-wav: Ranking Audio Files by Acoustic Quality

  996 words • 5 min read • Abstract

  rank-wav is a Rust CLI that ranks WAV files by acoustic features like spectral centroid, bandwidth, and RMS energy. It computes 'pleasing' and 'best' scores to help you quickly triage audio samples, synthesis outputs, or sound design variants.
• Part 7: pjmai-rs: Navigation History and Fuzzy Completion

  594 words • 3 min read • Abstract

  New pjmai-rs features: navigation history to revisit recent projects, smarter fuzzy tab completion, subdirectory navigation, and improved stack management. Building on the TBT post with practical workflow enhancements.
• Part 8: Personal Software #8: One Ring to Rule Them All --- sw-launcher's Memory Profiles, Heap Budgets, and a Working Scenario A

  4405 words • 23 min read • Abstract

  Thirteen sw-embed repos --- BASIC, Forth, OCaml, Pascal, PL/SW, Smalltalk, Tuplet, Macrolisp, Snobol4, APL, plus the resident-shell trio of monitor/script/yocto-ed --- each invented their own way to load code, runtime, source, and data into the COR24 emulator. The first sw-launcher schema (v1.1) tried to canonize their layout with a fixed 8 x 128 KiB partition grid; the second (v1.2) threw the grid out and replaced it with named memory profiles plus a `heap_justification` block, because the survey's real finding was not that the layouts varied --- it was that several of them were leaking. Phase 1 is shipped: `sw-launch run echo` actually exits 0 and prints "A" through the captured UART of a real `cor24-run` process. The post walks through both schema revisions, the memory-stance reversal that drove v1.2, and what works end-to-end today.
• Part 9: Personal Software #9: Vibe-Maintenance --- When AI Agents Don't Just Write Code, They Fix Bugs

  2523 words • 13 min read • Abstract

  The corollary to vibe-coding is vibe-maintenance --- AI agents not just writing new code, but fixing bugs in the constellation of demos, compilers, interpreters, and runtimes that the lab has accumulated. Twenty-eight sw-embed repos closed 141 issues in eighteen days. The web-sw-cor24-demos Status tab visualizes that activity as a closed-issues heatmap and a commit heatmap, alongside repo-level Try-it / In-dev badges. The post walks through the four bug-fix patterns the activity reveals (capacity-limit bumps, subtle codegen bugs, surface-level language features rolling in, and cross-cutting tooling bugs), and the human skill the cadence does not eliminate: writing an issue title that names the symptom precisely enough for the agent to act on it.

Sharpen the Saw Sundays

• Part 1: Saw #1: pjmai-rs, Rig, and langchain-rust

  2775 words • 14 min read • Abstract

  Sharpening the foundation: pjmai-rs gets critical Rust 2024 edition fixes and new features, plus a first look at Rig and langchain-rust---two Rust frameworks for building type-safe LLM agents and chain-based AI workflows.
• Part 2: Saw #2: reg-rs, avoid-compaction, and agentrail-rs

  1876 words • 10 min read • Abstract

  Three Rust CLI tools getting foundational upgrades: reg-rs moves to git-friendly text-based test definitions, avoid-compaction structures multi-session AI workflows with saga/step handoffs, and agentrail-rs adds in-context reinforcement learning to push agent reliability from 75% toward deterministic.
• Part 3: Saw #3: agentrail-rs --- From Walking Skeleton to Dual Memory

  1357 words • 7 min read • Abstract

  agentrail-rs went from walking skeleton to ICRL core loop, dual memory, distillation, and a hybrid orchestrator---all in one weekend. Next up: domain-specific Layer 2 repos, tested against three new projects that require C, Rust, Lisp, and Web UI skills.
• Part 4: Saw #4: All Together Now --- Emacs Meets the Multi-Agent Orchestra

  1237 words • 7 min read • Abstract

  Two CLI tools got full Emacs packages this week---pjmai-rs for project navigation and reg-rs for regression testing. Meanwhile, a new multi-agent Program Manager called All Together Now went from zero to four phases: PTY orchestration, web dashboard, and wiki-based agent coordination.
• Part 5: Saw #5: Sagas, Languages, and Compiler Chains

  1233 words • 7 min read • Abstract

  Agentrail-rs gained saga archiving for multi-saga projects. Meanwhile, a new ML language (MLPL) took shape, PL/SW got macros, and two compiler-chain fixes unblocked APL and BASIC on COR24.
• Part 6: Saw #6: Agent Coordination, Fuzzing Tests, Vendoring, and Emacs Graphics

  1331 words • 7 min read • Abstract

  All Together Now gained a multi-panel Web UI for coordinating Claude Code and opencode/GLM-5 agents. Fuzzit became an LLM-guided fuzzing tool that stress-tests CLIs and APIs. Vendoring in the COR24 compiler chain lets PL/SW and SNOBOL4 evolve independently. Emacs Graphics brings PaperBanana-styled SVG charts, menus, and presentations to Emacs buffers.
• Part 7: Saw #7: Prolog, Many-Agent Isolation, Self-Hosting Assembler, and MLPL

  1899 words • 10 min read • Abstract

  Rust-to-Prolog solves the classic Lion and Unicorn logic puzzles---a reference implementation that sets up a self-hosting COR24 port: PL/SW for the WAM-style runtime, SNOBOL4 for the lexer and parser. All-Together-Now scales to many concurrent agents with mosh, tmux, and per-user isolation on Arch Linux. The COR24 assembler begins self-hosting. sw-MLPL advances in parallel.
• Part 8: Saw #8: Tuplet, Smalltalk-on-BASIC, Forth-from-Forth, sw-MLPL Split, and I2C on COR24

  2481 words • 13 min read • Abstract

  Tuplet is a new experimental PoC language with significant whitespace and glyphs, set up as a playground for future language experiments---and the reason for installing Espanso and configuring Emacs as a shared glyph-input layer (also useful for GNU APL). An integer/toy Smalltalk written in COR24 BASIC works as a forcing function for BASIC; Tuplet plays the same role for OCaml and Forth. A new Forth-from-Forth runs in the browser via WASM. sw-MLPL splits into Linux/CUDA, Mac/MLX, and Web UI repos after its build dir crossed 35 GB. The COR24 emulator gains I2C support with examples, and the demo site's Status tab tracks the new languages with commits and issues.
• Part 9: Saw #9: Espanso, Kate, ShareX, and Pluggable I2C Devices on COR24

  3518 words • 18 min read • Abstract

  Three tools that turn out to be the same problem in disguise---Espanso for shared glyph input, Kate for one-XML-file syntax highlighting, and `gh gist create` standing in for ShareX---all earning their slot because they make collaborating on a new in-development language (PAL) cheap. Plus a deeper cut on the COR24 emulator: a three-layer I2C design (guest C apps / bit-banged bus state machine / pluggable device trait) that lets every COR24 language share the same I/O example library, with SPI sketched as a parallel phase 2.

Small Models, Big Brains

• Part 1: Small Models (1/6): 976 Parameters Beat Billions

  708 words • 4 min read • Abstract

  The best LLMs score zero on hard mazes. A model with 976 parameters scores 85%. The Tiny Recursive Model uses think-act cycles with deep supervision, proving iteration beats scale for tasks requiring backtracking and spatial reasoning.
• Part 2: Small Models (2/6): AI in Your Pocket

  770 words • 4 min read • Abstract

  AI in your pocket, no internet required. Pocket Eliza++ runs MobileLLM-350M on Android via llama.cpp and JNI, creating a privacy-first therapist chatbot. The 260MB quantized model achieves ~10 tokens/second on mid-range phones.
• Part 3: Small Models (3/6): Planner + Doer = Genius

  794 words • 4 min read • Abstract

  27 million parameters beats o3-mini on ARC. The Hierarchical Reasoning Model separates planning from execution, mimicking the brain's dual-process theory. It achieves 40% on the hardest reasoning benchmark where most LLMs score under 5%.
• Part 4: Small Models (4/6): This AI Has a Visible Brain

  851 words • 5 min read • Abstract

  LLMs are black boxes. Baby Dragon Hatchling uses brain-inspired sparse coding with 80% sparsity, making only 20% of neurons active per token. When fewer neurons fire, each one carries interpretable meaning. Train it on Shakespeare and actually see what's happening inside.
• Part 5: Small Models (5/6): Max AI Per Watt

  844 words • 5 min read • Abstract

  One billion parameters: the sweet spot for AI. Big enough to reason, small enough to run anywhere. Comparing TinyLlama, Llama-3.2-1B, StableLM, and Pythia with LoRA fine-tuning in minutes and speculative decoding for 2-3x speedups.
• Part 6: Small Models (6/6): Which Small AI Fits YOUR Laptop?

  979 words • 5 min read • Abstract

  Which small AI fits your laptop? Benchmarking Phi-2, Gemma-2B, and SmolLM on the 2-3B efficient frontier. Phi-2 achieves 61.7% MMLU with only 2.7B parameters, beating models 5x larger through synthetic textbook training. Data quality beats parameters.

Throwback Thursday

• Part 1: TBT #1: My First Program Was a Horse Race

  1131 words • 6 min read • Abstract

  My first program was a horse race game in APL on an IBM mainframe in 1972. This Throwback Thursday post recreates it using GNU APL, exploring array-oriented programming and the ideas that shaped languages from J to NumPy.
• Part 2: TBT #2: Pipelines on OS/390

  1784 words • 9 min read • Abstract

  Unix invented pipes. Mainframes reinvented them for records, not bytes. This Throwback Thursday recreates CMS/TSO Pipelines in Rust with a visual debugger, demonstrating record-oriented dataflow from the 1996 Olympics web server era.
• Part 3: TBT #3: Vector Graphics Games

  1638 words • 9 min read • Abstract

  Before pixels, there were vectors. Vibe Coding classic arcade games (Asteroids, BattleZone, Tempest) in Rust/WebAssembly with wgpu rendering---from my first encounter with an IBM 2250 to playable browser demos, all built in one day with Claude Code.
• Part 4: TBT #4: ToonTalk - Teaching Robots to Program

  1074 words • 6 min read • Abstract

  ToonTalk is a 1995 visual programming environment where you train robots by showing them what to do. I vibe coded tt-rs, a Rust/WebAssembly reimplementation with boxes, scales, birds, nests, and robots---programming by demonstration for the browser.
• Part 5: TBT #5: IBM 1130 System Emulator - Experience 1960s Computing

  1236 words • 7 min read • Abstract

  A browser-based IBM 1130 system emulator with authentic console panel indicator lights, keypunch, printer, and assembly game. Experience the full 1965 minicomputer ecosystem through interactive simulations. Work in progress.
• Part 6: TBT #6: PJMAI-RS - A Shell That Knows Your Projects

  1918 words • 10 min read • Abstract

  PJMAI-RS is a Rust CLI tool that maintains a registry of your projects and lets you switch between them instantly with short aliases. The clever part: it uses exit codes to signal a shell wrapper, allowing a subprocess to change your working directory.
• Part 7: TBT #7: reg-rs - Regression Testing from C++ to Java to Rust

  2047 words • 11 min read • Abstract

  reg-rs is a Rust CLI that captures command output as golden baselines and detects regressions on re-run. A clean-room rewrite of a tool I first used at Forte Software in 2000, later reimplemented as jregress at Sun (still maintained at Oracle), and now open-sourced in Rust with shell aliases, text-based test files, and AI-assisted test creation and maintenance.
• Part 8: TBT #8: wiki-rs --- Six Wikis, One Engine, Thirty Years of History

  1479 words • 8 min read • Abstract

  Six wiki implementations in Rust, tracing thirty years of storage evolution from flat files to git commits. What started as a throwback project became infrastructure for multi-agent AI coordination---with a Compare-and-Swap API that lets multiple AI agents safely share state through wiki pages.
• Part 9: TBT #9: UNIVAC Startrek, TRS-80 Adventures, and COR24 BASIC

  1467 words • 8 min read • Abstract

  Three BASIC games from three eras---UNIVAC 1108 Startrek whose Red Alert bell telegraphed Klingon encounters across the teletype room, a 1980s Trek text adventure typed in from a magazine listing on a TRS-80, and Robot Chase added at a friend's request---all running in the browser on an emulated COR24 integer BASIC implemented on a p-code VM written in Pascal.
• Part 10: TBT #10: Mass Compile and PL/EDIT --- 1980s Productivity Tools, Reborn on COR24 PL/SW

  2353 words • 12 min read • Abstract

  In the 1980s, I worked at IBM on PL/X systems code for an MVS/ESA time-sharing service called AQ --- hundreds of developers editing source on green-screen 3270 terminals, submitting batch compile jobs, sometimes waiting an hour for results. Two colleagues built productivity tools that absolutely changed the workflow: PL/EDIT, a template-driven editor that expanded common PL/X forms via hotkeys long before IDEs or Emacs were common, and Mass Compile, a batch-queue scheduler that let you submit compile jobs for code you had not written yet. Both have just landed in my COR24 PL/SW live demo. This post tells the original story and shows what was rebuilt.

Towards Continuous LLM Learning

• Part 1: Towards Continuous LLM Learning (1): Sleepy Coder - When Fine-Tuning Fails

  1216 words • 7 min read • Abstract

  What happens when you fine-tune a model on new tasks? It forgets old ones. This post documents our implementation of the Share algorithm in Rust—using SVD-based subspace extraction to enable continual learning without catastrophic forgetting. Part 1 covers the problem and initial negative results.
• Part 2: Towards Continuous LLM Learning (2): Routing Prevents Forgetting

  780 words • 4 min read • Abstract

  Part 2 of implementing the Share algorithm: after fixing critical bugs (zero-gradient saddle point, half-parameter training), routing-based coefficient selection achieves zero regressions. Result handling improved 40% to 50%. We're 60% through verifying the paper's claims.