Work with me
I build and deliver backend and agent systems as a one-person studio. I take a problem to production and I own the parts that are hard to get right: the failure modes, the boundaries, the things that have to still be correct at 3am when no one is watching. I work remotely with teams anywhere.
Most of what I do falls into two lines.
Agent and LLM systems
Putting a probabilistic model into a position of trust without trusting it. In practice that means:
- The wrapper, not just the prompt. Isolation, deterministic verification gates, reversibility grading, and a hard wall at self-modification — so an unreliable component can run unattended with a bounded blast radius.
- Agent orchestration that fails closed. A tool call with hallucinated arguments, a retry that fires the same side effect twice, a delegated agent holding permissions it should never have — designed away, not prompted away: tool scoping, idempotent boundaries, approval gates, delegation isolation. The safe path is the only path, not the one you hope the model follows.
- Grounding and integration. Wiring agents to real production systems (MCP, HTTP/SSE, retrieval) with the boundary contracts and observability that keep a bad input from becoming a silent hang.
Go backend systems
Services built to a strict engineering bar, the kind that holds up under review and under load:
- APIs and services — spec-anchored, tested to real failure paths, no optimistic happy-path-only code.
- Correctness discipline — a failing test before a fix, deterministic checks in the pipeline, small reviewable changes over large rewrites.
- Operational honesty — real exit codes, observable failures, nothing swallowed. If it broke, you can see that it broke.
Go is the first language; Rust is the second — for the smaller correctness-critical pieces (parsers, CLIs, verification tools), held to the same bar.
When the work needs a frontend, I ship that too — this site, public face and admin cockpit, is my Angular end to end. But that is the supporting line, not the pitch: you hire me for the system behind the screen.
Receipts
I would rather show you the work than describe it.
- Case study — Building a bounded-autonomy personal agent OS. The design and the failure modes of a local agent system I built and run unattended: the deterministic harness, the self-modification wall, the six-boundary launch gate, and a debugging war story about an SSE stream that hung for over an hour.
- koopa0.dev — my Go engineering blog, and the production knowledge-OS the agent above grounds against.
- GitHub — public work and profile.
How I work
Small, scoped, honest. I would rather deliver one thing that is actually correct than five that mostly work. I will push back on a plan I think has a hole in it — that is part of what you are hiring, not a nuisance. I flag the decisions that are yours to make instead of quietly making them for you. Fixed-scope or hourly, whichever fits the work.
Get in touch
Contact:[email protected]
If a mutual contact pointed you here, mention who — it helps me place the conversation.