I build software for systems that are hard to reason about.

Agents submit bounded, typed proposals; Rust validates the base tick and full allocation, checks invariants, and owns the only authoritative state transition. The first settlement turn is deterministic and atomic.

1. 01
   Bounded proposal

   Complete six-part allocation plus the expected base tick.

2. 02
   Rust validates

   Build a candidate state, then check every invariant.

3. 03
   Commit or reject

   S(0) becomes S(1) once; rejection leaves state untouched.

I built a fault-tolerant control plane for distributed compute. Workers report over gRPC; the orchestrator handles leases, priorities, and recovery.

1. 01
   Workers report

   GPU telemetry, uptime, version, and heartbeat state.

2. 02
   Orchestrator leases

   Capability filter, priority queue, and renewable job lease.

3. 03
   Failure recovers

   Stale nodes are evicted and expired work returns to the queue.

A C++17 2D particle engine with Verlet integration, boundary constraints, diagnostics, and naive O(n²) particle contacts. The spatial hash and honest benchmarks are still next.

1. 01
   Integrate

   Current and previous positions advance through Verlet steps.

2. 02
   Resolve

   Boundary bounces and all-pairs particle contacts on CPU.

3. 03
   Render + measure

   SFML frame output with FPS and particle diagnostics.

A functional Rust gateway that routes identical OpenAI-compatible requests across baseline and speculation-enabled vLLM, streams SSE without buffering, and measures whether speculation actually helps.

1. 01
   Route

   One request selects the baseline or speculation-enabled arm.

2. 02
   Engine owns speculation

   Draft proposal and target verification stay inside vLLM.

3. 03
   Stream + measure

   Pass SSE through while recording first output and total latency.