Skip to content

Posts

2026

  • The Kernel Trick, or: Geometry You Never Have to Visit

    Compute inner products in a million-dimensional feature space without ever going there. Kernels are the final substitute from the Infinite Dimensions post: geometry by algebra, taken to its limit. Attention is the same move, still paying off.

  • Manifolds: The Low-Dimensional Lie Inside Your Embeddings

    Your 1,536-dimensional embeddings live on something much smaller. What a manifold actually is, why interpolation works, why ANN indexes survive, and where the assumption silently breaks.

  • Why Everything Wants to Be Gaussian

    Sum enough weakly-dependent terms and you get a Gaussian whose mass sits in a thin shell. From the CLT to loss landscapes to initialization schemes—the bell curve is not a modeling convenience. It is what high-dimensional space does.

  • The Shape of Infinite Dimensions

    Nobody can picture four dimensions, let alone 1,536. Here is what mathematicians use instead of seeing—shadows, slices, unfolding, and arithmetic that functions as sight—and where your embedding model already lives by the same tricks.

  • Leases Are the Missing Primitive for Multi-Agent Coordination

    Multi-agent systems coordinate by convention—prompts, shared docs, please-don't-touch-this. Distributed systems solved this decades ago with leases. A lease is a bounded-time ownership claim that expires safely, and your agent framework needs one.

  • Reading Code That a Model Wrote: A Field Guide

    Code review didn't die when models started writing code; it changed substrate. What to actually check when the author is probabilistic, and why every caught defect calibrates you against that model's failure shape.

  • A Short History of Thinking in Many Dimensions

    From Riemann's 1854 lecture to Hilbert's function spaces: the story of how mathematicians learned to work where they cannot see, a century before embeddings made it a production concern.

  • Dimension Is a Design Choice

    384 vs 1,536 vs 3,072 embedding dimensions: what each buys, what each costs, and why more dimensions does not mean more meaning. Dimension is a budget, spent like any other.

  • Evaluation Is Load Testing

    Teams don't trust model changes for the same reason teams didn't trust deploys before CI: no cheap, repeatable signal. Eval suites are load tests—fixtures, budgets, regression gates, canaries. What transfers from performance engineering, and what doesn't.

  • Capacity Planning for Agent Fleets

    Agents are bursty, stateful, long-running tenants. Treating them like stateless request traffic produces idle spend and midnight pileups. Little's Law, head-of-line blocking, and sizing for p99 instead of average.

  • The Two Generals Problem in Agent Communication

    When a parent agent hands work to a subagent, neither can ever be certain the other got the last message. The oldest impossibility result in distributed computing explains duplicated tool calls, lost completions, and agents that wait forever.

  • Circuit Breakers for Tool Dependencies

    An agent calling a dying API will hammer it harder, not softer, because its loop cannot tell one failure from an outage. The circuit breaker pattern ports to tool calls—with a twist: LLM retry creativity defeats naive trip conditions.

  • Write-Ahead Logs: Why Your Agent Framework Needs a Journal

    Long-running agent sessions crash mid-task and lose everything. Databases solved durable partial work in the 1970s with one idea: write intent before action. An agent loop is a transaction processor, and it deserves a journal.

  • Context Engineering Is API Design

    What you put in context, in what order, with what volatility, is an API contract—between your components, and between runs. Schema-first thinking for prompts: versioned templates, stable prefixes, changelogs, diffs.

  • Prompt Caches Only Hit When Prefixes Match

    Prompt caches give a 90% discount on input tokens, but only when request prefixes match. Why KV-cache reuse is positional, and what that means for API design.

  • The Failure Modes of Generous Tools

    The single worst property a tool can have is helpfulness. Pagination, honest counts, structured errors, idempotency—tool design is the actual lever on agent reliability.

  • Agent Loops Need Backpressure, Not Bigger Context Windows

    Agent context windows are unbounded queues. Classic flow control—backpressure, admission control, compaction—fixes agent failures that bigger context windows never will.

  • Agent Skills Need a Runtime, Not a Prompt

    Agent Skills Need a Runtime, Not a Prompt

  • Understanding One-Step FB: Reinforcement Learning Through Representations

    A practical introduction to One-Step Forward–Backward methods and how they turn long-horizon reinforcement learning into representation learning.

2023

2022

2019