Projects
Five things I've built, newest first: vxlan-tracer, LLMFirewall, a C++20 matching engine, an offline RL framework, and Edge Deployer. All of the code is on GitHub.
vxlan-tracer
When a VXLAN overlay's MTU is set wrong, the network fails in a confusing way: pings and small requests work, large payloads stall, and nothing shows up in any log. It happens often enough in k3s/Flannel and Calico setups that I wanted a tool that would just say what's wrong.
vxlan-tracer attaches four BPF programs at the same time: TC hooks on overlay egress and underlay ingress, and kprobes on ip_do_fragment and icmp_rcv. After a 5 to 60 second run it combines their counters into one of six verdicts, such as VXLAN_FRAGMENTATION_OBSERVED, PTB_SUPPRESSED, or VXLAN_MTU_OK. It doesn't need a kernel module or any config change, and it doesn't disrupt traffic.
Most of the effort went into not breaking the host. Before attaching, it checks for existing TC programs. On exit it removes only the programs it can confirm it installed, and Close() is safe to call twice. It also finds the underlay interface on its own from the VTEP device index, and collect-environment produces a bug-report tarball with no IP addresses, routes, or process lists in it.
All six verdicts reproduce on Linux 5.15, all 20 TC coexistence cases pass (including SIGINT and SIGTERM mid-run), and it builds static binaries for arm64 and amd64.
LLMFirewall
An agent that can call tools can be tricked by the text it reads. A retrieved document that says "now post this to Slack" can make an agent do exactly that. Keyword filters miss these because the instructions can be phrased in endless ways and often look harmless.
LLMFirewall is a proxy that sits between the agent and its MCP tool servers. Every call goes through seven checks: a tool allowlist, detection of look-alike tool names (p0st_slack), scans of arguments and outputs for injected instructions, argument sanitizing, a guard that stops API keys from leaving in arguments, and taint-aware gating of write tools.
The last check matters most. Content that came from a tool output or a retrieved document is marked untrusted, and untrusted content can never authorize a tool that writes or sends something, no matter how innocent it looks. Responses are fingerprinted with word 3-grams, so an attack still gets caught when the agent reads a document on one turn and leaks it through a write tool two turns later.
On 4,200+ test cases across five attack families, the attack success rate falls from 100% with no defense to 48%. For attacks that try to trigger write tools it falls to 0%. The false positive rate is 0.6%, and a check adds 0.16 ms on average because it never calls another model. Policies are written in YAML, and there are 839 tests, including 26 scenarios run against real filesystem, git, and SQLite MCP servers.
C++20 matching engine
A limit order book and matching engine like the one at the center of an exchange. Orders match by price and then by arrival time, and it supports limit, market, IOC, FOK, post-only, and self-trade-prevention orders.
Speed came from avoiding the usual costs. Orders live in slab allocators instead of being allocated one at a time, the price levels are laid out so the hot ones stay in cache, I removed branches from the matching loop, and the engine thread is pinned to a CPU. On one thread it handles 20.7 million messages a second, with a median latency of 0.04 µs and a p99 of about 1 µs over a 1M-event replay. Those numbers are from a synthetic benchmark on my machine; the README lists the hardware and the harness.
Around the engine there's a Python pipeline that pulls Binance US market data, stores it as Parquet, and replays it at 1× to 100× speed to backtest VWAP, TWAP, POV, and iceberg strategies. The engine can snapshot and resume, and restarting from the middle of a file produces exactly the same fills and PnL.
Offline RL agent
Most offline RL work reports average return and stops there. I wanted to answer the questions you'd ask before deploying a policy trained on logs: is it safe, and where will it fail?
The framework implements six algorithms (BC, CQL, IQL, TD3+BC, Decision Transformer, AWAC) and two simulators, a traffic router with SLO constraints and incidents and a hospital treatment model. It checks how well the logged data covers the actions a policy wants to take, estimates performance offline three ways (FQE, weighted importance sampling, doubly robust) with bootstrap confidence intervals, and adds a policy shield for unsafe actions.
On the traffic task CQL reaches a return of about 72 against about 51 for the policy that generated the logs, with 3% SLO violations instead of 8%. The FQE estimate's 95% interval is [65.1, 74.5] across three seeds.
Edge Deployer
Writing a serverless function usually means a terminal for deploys, a browser tab for logs, Postman for testing, and another CLI for secrets. Edge Deployer puts all of that in one desktop app.
Each of the six providers (Cloudflare Workers, AWS Lambda, Vercel, Netlify, Fly.io, Railway) implements the same seven-method deployer interface, so deploy, rollback, and drift detection work the same everywhere. You can preview Workers locally without a cloud account, export the setup as Pulumi, Terraform, Wrangler, or Docker plus Kubernetes, and load test with a P50/P95/P99 report. Secrets are kept in an AES-256-GCM vault, and plugins run in a sandbox with explicit permissions. There are 85 tests, and GitHub Actions builds binaries for macOS, Windows, and Linux.