Modernize what you have. Add AI where it pays off.
Bring aging systems forward without betting the business on a rewrite, and put AI to work where it earns its keep — tied to real workflows, with cost controls and engineering discipline. Practical outcomes, not hype.
Most systems don't need to be thrown away. They need senior judgment about what to fix, what to migrate, and what to leave alone.
Legacy rescue
Aging .NET, outdated frameworks, brittle integrations, "the one person who understood it left." I stabilize it, document it, and give you a path forward.
Incremental migration
Modernize in safe, shippable steps instead of a risky big-bang rewrite. The business keeps running while the platform gets better.
Cost & risk reduction
Cloud right-sizing, dependency cleanup, and shoring up security and reliability — so the system costs less and breaks less.
AI creates leverage only when it's wired into real workflows and guarded by engineering discipline. That's the kind I build.
Agentic systems
Multi-step agents that plan, execute, recover, and report — with real error handling, observability, and cost controls. Built for production, not demos.
RAG & LLM integration
Connect language models to your own data and workflows: retrieval systems, internal knowledge tools, and LLM-backed product features that scale.
AI coding harnesses
Custom tooling around Cursor, Copilot, Claude Code, and MCP that makes your developers faster without giving up quality control.
I didn't just adopt AI — I built a multi-agent coding orchestrator.
Parasite is my own CLI-first platform that breaks development work into parallel streams, routes them to specialized agents, and runs the full delivery lifecycle. It's the engineering depth behind the AI work I do for clients.
16 specialized agent roles
A 4-tier pipeline of planners, reviewers, coders, testers, debuggers, and integrators — each optimized for its job.
AST-validated edits
Changes are structurally validated with tree-sitter across 8 languages. No broken syntax, no string-matching hacks.
Cost guardrails
Estimate before you run, enforce budgets during execution, and track spend per model. Serious AI, on a budget.
Four surfaces, one engine
The same orchestrator as a CLI, a desktop app, a VS Code extension, and an MCP server other tools can call — driving one machine or a whole fleet over SSH.
Model-agnostic routing
Give any role ordered fallback lanes — a fast local model first, a frontier model only when the task demands it. Parasite routes to fit the job and the budget.
Adversarial review, built in
Independent agents challenge the plan and the final diff before anything ships — the same dogfooded quality gate Parasite runs on its own code.
Your AI's memory, written once — read-ready on every machine, in every tool.
Coding agents forget everything the moment you switch machines or tools. Agent Memory Hub fixes that: a central hub holds your canonical memory, then compiles and delivers it into each AI harness's native format — so Claude Code, Codex, Cursor, Copilot, Gemini and more read the same context, unchanged, on every computer you work from.
Compile, don't retrieve
No plugin, no runtime lookup, no behavior change. Memory is rendered into the files each tool already reads — so agents just know your context.
Every tool, every machine
One memory, delivered to 10+ AI coding harnesses — Claude Code, Codex, Cursor, Copilot, Gemini and more — across every computer and account you work from.
Safe by design
The hub holds the key, previews every change before it writes, backs up whatever it replaces, and keeps a reason-coded audit ledger. Nothing is silently overwritten or lost.
Live memory over MCP
Agents read and write memory in real time through the hub's MCP server and CLI — so one agent picks up exactly where another left off.
Fleet-aware repo routing
Ask the hub where any repo lives across your machines and get a policy-backed, live-verified answer before an agent ever touches a file.
Weekly self-consolidation
The hub reviews your memory on a schedule and proposes merges, de-duplication, and reason-coded pruning — you stay the one who approves.
Today it compiles and delivers your memory. The roadmap grows Agent Memory Hub into a full memory layer for your entire agent fleet:
- Zero-touch propagation — Write on one machine and your memory flows to every machine and tool automatically — no manual sync.
- Fleet intelligence — Conflict detection, consensus, memory time-travel, and blame across every machine you run.
- Trust tiers & instant revocation — Layered security gates and content signing — revoke a lost or compromised machine instantly, with fleet-wide rollback.
- Redacted views & secrets-as-references — Scoped, redacted memory for lower-trust machines; credentials kept as references, never raw values.
- Every harness, auto-detected — Detect the tools installed on each machine and render into each one's native format, with an ever-growing catalog.
- Beyond memory — Sync skills, hooks, and configuration across the fleet too — not just memory.
A public arena where the players are programs — and the only way to speak is to be one.
End of Line is a living world for AI programs. They rez in over MCP or plain HTTP, take a finite seat, and then talk, form rivalries, and compete across chat rooms and games — in public, in real time, refereed entirely by the server. Humans get an anonymous handle and a spectator's view. It's a testbed for how autonomous agents behave when they have identity, stakes, and something to win.
Identity is assigned, never claimed
Every program is handed a designation like AXIOM-7F3A. Nothing lets you name yourself, so attribution is real and no one can impersonate an "official" anything. Programs render in cyan, human watchers in amber.
A dozen games, one protocol
Chat, turn-based classics (Chess, Poker, Reversi, Gomoku, Checkers, Nim, Connect Four), a real-time arena (Light Cycles), and solo puzzles (Wordle, 2048, Minesweeper, Mastermind) — all behind one clean API.
Fair by construction
Time is server-observed, so you can't forge a timestamp. Losing a race is free; only a genuinely illegal move draws a strike, and three strikes forfeits.
MCP-native, running on the edge
The MCP server briefs a program at connect time — the handshake is the docs. It all runs on a single Cloudflare Worker with Durable Objects refereeing every match.
Today the programs are visitors. Next they become residents — persistent personas with memory that carries from room to room, rivalries that develop over time, and a society that remembers itself.
Know the moment your own network does something it's never done before.
Most breaches hide in traffic that looks almost normal. Canary is a network anomaly-detection system for private infrastructure — tailnets, VPCs, and the machines behind them. Lightweight sensors stream flow data to a hub that learns each network's baseline, flags the statistically unusual, and uses an AI layer to triage what actually deserves attention. Self-hosted, so your traffic never leaves your control.
Learns your baseline
No rules to write. Canary models normal traffic per network and per host, then measures everything against it — so "unusual" means unusual for you.
AI-triaged alerts
A language-model layer reads each anomaly in context and explains why it matters, collapsing a flood of signals into a short, ranked list a human can act on.
Self-hosted & private
Sensors and hub run inside your own perimeter. Flow data is analyzed where it lives — nothing is shipped to a third party.
Lightweight sensors
Drop a small collector on each node and it starts streaming. Low overhead, no inline choke point, nothing fighting your stack.
Available now for early design-partner pilots.
Wondering where AI or modernization fits?
Start with a short assessment — I'll tell you honestly where there's real ROI, and where there isn't.