/about
About Me
I'm a software engineer who believes that the quality of a system is measured not by what it does when everything goes right, but by how precisely it behaves when it doesn't. I build infrastructure for agentic AI — the layer between raw inference and reliable execution.
Background
My engineering philosophy is rooted in a single conviction: non-determinism is a bug, not a feature. Most failures in complex systems — agent loops that drift, streams that corrupt, builds that flake — trace back to unacknowledged entropy. I build tools that eliminate those sources by design.
Working primarily in Rust and TypeScript, I focus on the layer between raw inference and reliable execution. This includes building spec-compliant protocol implementations like the Agent Client Protocol (ACP), and high-performance streaming clients like the xai-grok library.
When I'm not engineering, I'm reading protocol specifications, hardening systems against non-deterministic edge cases (using techniques like chunk-boundary fuzzing), and refining multi-agent orchestration models that remain stable even as they scale to multiple parallel sub-agents.
Timeline
Independent Systems Engineering
Designing and building open-source infrastructure for agentic AI — from byte-level protocol parsing to deterministic orchestration frameworks. Focused on Rust and TypeScript at the intersection of LLM tooling and distributed systems.
Deep dive into LLM Infrastructure
Began systematic reverse-engineering of LLM provider streaming APIs (OpenAI, Anthropic, xAI). Identified fundamental gaps in existing tooling and started building spec-compliant alternatives from scratch.
Systems Programming — Rust
Transitioned to low-level systems engineering. Learned Rust and applied it to high-throughput networking and binary protocol design, valuing safety guarantees without garbage collection overhead.
Software Engineering Foundations
Started engineering software seriously. Built a foundation in TypeScript, distributed systems design, and network protocols. Became obsessed with determinism as a design principle.
Engineering Values
Clarity over cleverness
Code should communicate intent unambiguously. Clever abstractions that obscure behaviour are technical debt by another name.
Correctness before performance
A fast system that produces wrong results is worse than a slow correct one. Profile before optimising; measure before claiming.
Ownership of the stack
Understanding every layer you depend on — from the protocol spec to the OS scheduler — is not optional. It is the craft.