Hi I build agentic nervous systems: realtime reactive primitives coordinating agents, models, and software across the web, developer workflows, and process/network boundaries.
I'm working across my own projects and various open source projects, including lazy-reactive signals spanning FFI, IPC, WebSockets, and WebRTC.
Featured
Signal Is Not a Reactive Primitive
Signal is a composition of a memoized slot and a puller effect... five lines, in every binding. The frontend ecosystem promoted it to a primitive, and the TC39 proposal quietly didn't. Plus: why weak back-edges are an ergonomics driver before a performance one, what non-GC languages pay instead, and how naming ambiguities are a reliable way to find architecture bugs.
Realtime Agentic Development
Agent harnesses are already becoming realtime development environments. Loops, goals, living specs, salience, and software feedback start to look less like ticket workflows and more like musical looping.
A Spreadsheet at Google-Sheets Scale: Cell Families and Focused Recompute in lazily-rs
lazily-rs now backs a full-capacity Google Sheets workbook — 10,000,000 cells — and the part that matters isn't the build time, it's that editing one cell and reading a 1,000-cell viewport costs ~11 microseconds no matter how big the sheet is. This post walks through the two new keyed primitives that make it possible — CellMap and CellFamily — and the lazy pull-based model that recomputes only the cells you focus on, with diagrams of coarse-vs-fine-grained reactivity and the spreadsheet graph.
Reactive State Machines: How lazily-rs Drives agent-doc's Cycle State
A finite state machine shouldn't be a pile of scattered if-checks. This post shows how lazily-rs's StateMachine primitive — a Cell-backed FSM with a pure transition function and reactive observers — became the single transition authority for agent-doc's per-document cycle state, replacing ad-hoc phase guards with one declared table. With diagrams of the phase graph, the FSM-plus-durable-journal architecture, and how the same reactive graph that runs your UI can run your protocol.
Slot → Cell → Signal: Composing Lazy and Eager Reactivity in One Graph
How lazily-rs composes three primitives — Cell, Slot, and Signal — so you can pick lazy (compute-on-read) or eager (recompute-on-change, no unset window) per derived value inside a single dependency graph. With use cases and diagrams.
The lazily Architecture: One Reactive Graph from Local Memory to the Network
A full-architecture tour of lazily — the reactive core (Context, Cell, Slot, Signal, Effect), the three execution contexts (single-threaded, thread-safe, async), the Snapshot/Delta wire protocol that carries the same graph state across IPC, WebSocket, WebRTC, and FFI, and the cross-language family. With use cases and diagrams.
Runbooks — On-Demand Procedural Context for AI Agents
A convention for externalizing step-by-step procedures from CLAUDE.md and AGENTS.md into on-demand runbook files, saving context window tokens while keeping agent workflows discoverable.
532 Commits in One Day: What Multi-Agent Sessions Reveal About Security and Debugging
A single day with 11 parallel agent-doc sessions produced 532 git commits across bug fixes, correspondence, and feature development. The debugging session alone took 292 commits to untangle snapshot rollbacks, duplicate writes, and session lifecycle failures. Here's what dog-fooding an agentic tool teaches you about multi-user security and complex debugging.
Existence-Lang: Pneuma, Noumena & Phenomena in Software Ontology
A deep dive into existence-lang ontology development — building a formal language for modeling reality in software systems. Explores pneuma, noumena, phenomena, universal applicability, precision as possibility space, and permaculture as systemic design.
Agent-Doc: Building a Cross-Platform FFI Plugin with Socket IPC
Live session replacing file-based IPC with cross-platform socket communication in agent-doc's FFI plugin backend — centralizing editor plugin logic in Rust rather than duplicating across JetBrains, VS Code, Vim, and Zed.
Module Harness, Back-Testing, and Building a Domain Ontology with Agents
A live session exploring module-level harness context for agent-doc, back-testing concepts for evaluating harness effectiveness, agent teams vs organic architecture, and the first real usage of existence language to build a domain ontology — with the agent defining its own terminology.
Skill to Binary: Debugging agent-doc Live — 6-Part Mini-Series
A 7.5-hour live coding mini-series documenting the migration of agent-doc's boundary management from the Claude Code skill into deterministic binary/plugin code — and the cascade of bugs discovered along the way.
Building Agent Resume: AI-Powered Job Search Workflow with Resume Generation
A live coding session building agent-resume — a TOML-based system for generating tailored resumes for job applications, phone call transcriptions, and email correspondence using corky and agent-doc.
Building Agent-Doc: Live Debugging tmux Race Conditions & CRDT Document Sessions
A live coding session working on agent-doc, corky, and tmux-router — covering Google OAuth app verification, tmux pane proliferation debugging, CRDT document session management, and markdown AST parsing.
Lazily: Reactive Primitives Done Right — Context, Slots, Cells, and Signals
Introducing lazily — a multi-language reactive primitives library (Rust, Zig, Python) built on lazy invalidation. Deep dive into Context, Slot, Cell, and Signal abstractions, lazy vs eager reactivity, and how proper hydration (code and body) eliminates waste.
Introducing agent-doc: Documents as the UI for AI Agents
agent-doc turns markdown files into persistent, editable, version-controlled conversations with AI agents. No more ephemeral chat — your documents are the UI.
Tag Vector: Part 0: Introduction
Tag Vector is a name system where tags connected as a vector form a name. Tag Vector can name variables, functions, components, network apis, low code apps, & prose.
Recent Posts
Eight Implementations, One Spec: Redundancy as an Epistemic Device
Building the same reactive library in eight languages against a shared normative spec, a Lean model, and a load-test harness ... and what that combination found that no single implementation could. Why six normative clauses accumulating around one primitive meant the primitive was wrong, which is also the honest answer to 'isn't a reactive just an observer?'. Five ways a conformance suite reports green while checking nothing. Benchmarks that lied by 2x on a busy workstation.
Ep6: Deterministic Primitives — Skill to Binary Series
The design principle that emerged: put deterministic operations in the binary, let agents handle probabilistic coordination. Session wrap-up and reflections on AI-assisted development velocity.
Ep3: AST Parsing & GPU Transcription — Skill to Binary Series
Replacing regex with pulldown-cmark AST, debugging boundary markers across IPC paths, adding CUDA GPU transcription to corky, and designing the YouTube publishing pipeline.
Ep1: The CRDT Ordering Bug — Skill to Binary Series
CRDT merge preserves data but not semantic ordering. Debugging how user prompts end up below agent responses, discovering IPC caching as the root cause, and a philosophical detour about 'vibe coder' labels.