Building systems that have to be right on real hardware. 17. Edge-first. The work lives at the boundary where a model's opinion stops and an auditable decision has to be made. 15 models on HuggingFace (fine-tunes, GGUF/MLX exports, Nemotron conversion forks), 4,300+ cumulative downloads.

I open PRs upstream when the fix is general. Some merge, some don't. Here's the full record.

• roboflow/roboflow-python#495 — Reviewed the api-key CLI PR (authored by @yeldarby, Roboflow CTO). Three findings the author addressed before merge: (1) root-caused a numpy 2.5.0 × mypy PEP 695 CI failure blocking the entire repo, (2) caught custom_metadata vs customMetadata camelCase bug silently dropping metadata on every api-key create, (3) flagged error hint accuracy in protect/disable handlers.
• roboflow/roboflow-python#498 — Opened the issue diagnosing the CI failure, opened PR #499 with the fix, then closed my PR in favor of #495 after coordinating with the author.

I fine-tune and publish models on HuggingFace. 15 models, 1 dataset.

adaptive-operator-v4-dataset — SFT + DPO training data for agentic tool use (4,992 SFT examples, 5,000 DPO pairs).

These are observations I keep arriving at, not slogans I started with.

Neural networks identify. Algorithms decide. Judgment does not belong in floating-point weights. Put the decision logic in config, make it auditable, and let the network do what networks are good at — perception. A facility rule change should not require retraining.

Freeze the wire, evolve above it. The protocol is not the place to be clever. Bake interfaces, not algorithms. The acid test for any addition: does it make the system more capable, or merely more complicated? If it's merely complicated, it belongs in an implementation, not the spec.

A working deterministic version beats a broken AI version. Ship the heuristic first. Label it as an estimate. No fake precision. Add the LLM later, when it earns its place.

Hardware reliability is table stakes, not an afterthought. Cameras drop. Indexes enumerate wrong. The system has to reconnect, auto-detect, and keep grading. "Validated against the wrong camera" is a real failure mode I have shipped and then fixed.

Read-only by default. Destructive actions commented out. A scan that can't break your machine is a scan people will actually run. Remediation scripts get reviewed by a human before anything runs.

Trust is a continuity problem, not a one-time check. Before an agent calls a capability it didn't build, it needs to know what it is, who authorized it, whether it has changed, and whether this specific call is allowed. A boolean from the agent itself is not evidence — the verification has to produce the evidence, not consume it.

Reality remains the final authority. A neural network can be wrong about a fruit. A system misaligned with facility rules is useless. The README should say what's pending, not what's impressive.

Real-time CV pipeline for apple variety detection and USDA-style grading, built for the family orchard. YOLO26 detects; a grading_policy.yaml file grades. Defects bind to apples via Intersection-over-Area. Low-confidence frames are harvested as free training data. Runs on the Apple Neural Engine through CoreML. This is the project where my principles actually have to hold up against a piece of fruit.

A post-quantum, agent-first P2P networking stack. Rust reference (19 crates, ~140K lines), a TypeScript SDK, and a Go implementation written strictly from the RFCs to validate that the wire format is unambiguous. The transport is frozen at Rev 6; the work above it is an Intelligence Plane — predictive routing, intent routing, reputation, pubsub. The competitor is not HTTP. The competitor is cloud silos that own the agent graph.

Cryptographic trust infrastructure for MCP servers — content-addressed capability identity, Ed25519-signed manifests, TOFU pinning, and two-gate call-time enforcement. Ships with an empirical health scanner (the "npm audit for MCP") that probes a server and produces a scorecard instead of trusting the agent's self-attested booleans. Three-engine danger detection: heuristic, semantic, and prompt-injection fusion.

A local-first AI operating system for macOS — an intelligence layer over the computer, not a chatbot. It reasons, retrieves, chooses tools, executes, verifies, and explains. The part I'm proudest of is the PR governance system: an evidence-producing state machine (DRAFT → UNDERSTOOD → VERIFIED → PR_READY) that captures real command output tied to a commit, so an agent can't fake "tests pass" by claiming a boolean. Includes an engineering-intelligence/ module for architecture analysis and risk mapping.

A macOS system sanitizer and discovery tool in Rust. Every engine is read-only. Privacy redaction is on by default — home paths, tokens, keys, emails, IPs. Remediation scripts are emitted with destructive commands commented out and paths shell-quoted against injection.

Point it at an abandoned repo. Get an opinionated architecture, risk, and onboarding briefing in seconds. Zero runtime deps, offline, deterministic. The v1 deliberately avoids LLM prose — a working heuristic is more useful than a broken AI version.

• Edge ML on Apple Silicon — CoreML, the Neural Engine, and the gap between a notebook model and a pipeline that survives a real camera.
• Distributed systems and protocol design — DHTs at scale, NAT traversal, post-quantum handshakes, and what it takes to make a spec unambiguous enough to implement twice.
• Agent infrastructure and trust — MCP security, signed manifests, TOFU pinning, and the governance layer that keeps autonomous agents from routing around their own constraints.
• Developer tooling — tools that read a system or a repo and tell you something true, with zero config and no API key.
• Native macOS software — Swift, SwiftUI, and apps that feel like they belong on the machine.