● 27 things I've shipped

Stuff I've built.

Real things I have built — healthcare products running in clinics, and the AI agent systems that build, voice, and ship this very site.

01 Music Education

Tutti

Classical music, without the intimidation

A bilingual classical-music learning product that guides people through pieces with stories, context, and things to listen for — not intimidating analysis or assumed expertise.

The problem: Classical music can feel locked behind jargon, theory, and an expectation that newcomers already know how to listen.
Who it's for: Amateur listeners and newcomers who want a bilingual path into classical music
The payoff: A welcoming way to hear more in every piece, build confidence, and turn curiosity into a lasting listening habit.

Bilingual UX
Guided Listening
Story-First Learning

Visit live site

Live queue 4 waiting · avg 12m demo

Checked in

In queue

Roomed

Done

02 Healthcare AI

Patient Portal

An operating system for an urgent-care clinic

A single web platform that runs a clinic's whole day — check-in, a live provider queue, lightweight charting, telehealth, staff messaging, and billing — instead of a dozen disconnected legacy tools.

The problem: Clinics juggle fragmented systems with no shared real-time picture, so nothing improves quickly.
Who it's for: Urgent-care clinics + their front-desk, clinical, and billing teams
The payoff: Real-time queue visibility, faster patient throughput, less manual charting, and operations you can actually iterate on — all in one owned surface.

TypeScript
React
Redis (SSE)
Twilio
Stripe

jon@fleet — agent session

▋

03 Agent Infrastructure

Firstmate

One captain-facing harness for a whole agent crew

The sole captain-facing product surface for dispatching agent work: Firstmate routes goals through persistent secondmates, keeps subordinate workers internal, and watches sessions for trouble — rate limits, context exhaustion, dead sessions — so work can recover automatically. This work builds on Firstmate, Kun Chen's open-source project.

The problem: A single agent is a toy. A dependable system needs many agents, coordinated, supervised, and safe enough to run unattended.
Who it's for: Anyone running AI agents that must stay up and do real work
The payoff: Agents that run real work overnight, detect their own degradation early, and recover with full context — including building and shipping this site.

TypeScript
Bun
Claude Code
tmux
systemd

Visit live site

04 Clinic Operations

Patient Intake

Self-service check-in that finishes before the visit starts

A kiosk and mobile intake flow where patients check themselves in — confirm demographics and insurance, sign policies, answer pre-visit questions — and drop straight into the live clinic queue.

The problem: Front desks are the bottleneck during a rush, and half-finished intake stalls the provider.
Who it's for: Urgent-care clinics + arriving patients
The payoff: Faster check-in, complete structured data before the patient is roomed, and real-time arrival alerts for staff.

TypeScript
SSE
Twilio
OCR
Kiosk UI

05 Agent Infrastructure

Agent Machine Fleet

A private cluster of machines, each running AI agents

A network of dedicated computers, each running autonomous agents that write code, review PRs, and automate browsers — isolated from my main workstation so nothing contends or bleeds context.

The problem: Running many agents on one machine causes contention, instability, and context pollution.
Who it's for: Teams + solo builders scaling AI work across hardware
The payoff: Dispatch-and-forget delegation, true parallel work across many repos at once, and zero pollution of my own environment.

Claude Code
tmux
SSH
systemd
GitHub Actions

06 Dev Tooling

CODY — Self-Evolving Code Reviewer

A reviewer that gets sharper with every pull request

An AI code reviewer that posts formal PR reviews, then learns from each one — capturing what it missed, researching detector improvements, and auto-merging upgrades to itself, all on fresh throwaway containers for security.

The problem: Off-the-shelf review bots repeat the same misses forever and learn nothing.
Who it's for: Engineering teams that want review that improves over time
The payoff: Precision that compounds PR over PR, a 'prove-it, don't assert-it' culture, and ephemeral-runner security that keeps secrets local.

TypeScript
Claude Opus
GitHub Actions
Docker

07 Knowledge Systems

Second Brain Knowledge Engine

Hybrid retrieval that actually understands your notes

A knowledge system that answers questions over thousands of notes by blending three methods — LLM reasoning, a graph database, and vector search — then synthesizes one cited answer and flags what's missing.

The problem: Pure vector search misses relationships; pure keyword search misses meaning.
Who it's for: Anyone with a large personal or organizational knowledge base
The payoff: Fast, precise, cited answers across a whole vault — graph traversal for relationships, vectors for meaning, reasoning to tie it together, with honest gap-flagging.

Neo4j
PostgreSQL
pgvector
LightRAG
Claude

08 Media & Voice

Fleet Voice System

Gives every machine and notification its own AI voice

A self-hosted text-to-speech system where each source speaks in a distinct voice, plus a 'Fusion Lab' that blends voices in embedding space to invent brand-new ones — for notifications, narration, and the video voiceovers on this site.

The problem: Audible notifications only help if you can tell what they're from, and custom voices normally need costly APIs.
Who it's for: Builders of voice apps, agent operators, and content creators
The payoff: Source-identifiable spoken alerts, true embedding-space voice blending (not splicing), and a self-hosted alternative to paid voice APIs.

Qwen3-TTS
x-vector embeddings
Whisper
TypeScript

09 Agent Infrastructure

Multi-Account AI Load Balancer

Routes AI work across accounts to dodge rate limits

A smart launcher that picks among many AI accounts by available headroom and fails over automatically, so a single rate limit never silences the whole system. New accounts are discovered from disk with zero code changes.

The problem: One account hitting its limit can halt every agent that depends on it.
Who it's for: Heavy AI users running many concurrent agent sessions
The payoff: Continuous uptime under heavy load, automatic failover, and anti-concentration routing so no single account gets overloaded.

TypeScript
Bash
Claude API
systemd

10 Healthcare AI

AI Chart & Coding Auditor

Catches medical billing-coding errors automatically

A service that continuously reviews clinical encounters with rule packs plus an LLM, flagging common coding mistakes — mis-leveled visits, wrong patient class, missing codes — each with a confidence band and a suggested fix.

The problem: Provider-side coding errors quietly cost clinics real revenue, and manual audits eat staff time.
Who it's for: Billing, coding, and compliance teams at urgent-care clinics
The payoff: Recovers revenue lost to coding errors, cuts manual audit labor, and produces per-provider trends for coaching.

TypeScript
local LLM (vLLM/Qwen)
EMR API
SQLite

11 Healthcare AI

Claraly — Patient Engagement Assistant

A safe AI front desk and follow-up over text

An AI assistant that handles patient texting — routine questions about hours and services, wait-time updates, automated post-visit follow-up — and routes anything clinical straight to a human.

The problem: Front desks drown in routine calls, and post-visit follow-up is inconsistent.
Who it's for: Urgent-care front-desk and clinical teams
The payoff: Fewer routine calls, faster replies, and automated recovery check-ins — with strict human-in-the-loop safety so it never gives medical advice.

LLM (GPT-4 / Claude)
Twilio SMS
n8n
Langfuse

12 Agent Infrastructure

Fleet Health System

Continuous health monitoring and triage for AI agents

A 'hospital' for AI agents: a sensor checks every agent's vitals — context pressure, rate-limit status, liveness — flags trouble early with smooth scoring, and performs consent-gated treatments like compaction, transfer, or resurrection.

The problem: Agents fail quietly, exhausting context or hitting limits with no warning.
Who it's for: Operators of persistent agent fleets who need reliability
The payoff: Early degradation detection, no-cliff smooth scoring, treatment that never overrides a refusal, and a live board showing the whole fleet at a glance.

TypeScript
systemd
tmux
Claude API
JSONL

13 Dashboards

Heads-Up Dashboard

A calm daily brief that surfaces only what changed

A personal dashboard that folds many streams — commitments, deals, infrastructure health, spend — into one narrative brief, and stays quiet until something materially changes so it never becomes wallpaper.

The problem: Operating pictures scatter across tools, and delegated work falls through silently.
Who it's for: Solo operators and small teams who want awareness without noise
The payoff: Commitments first, nothing-drops tracking, material-change detection that suppresses churn, and a brief you can scan in seconds.

TypeScript
Bun
material-change detection
mTLS

14 Agent Infrastructure

Agent OS — 'The Nation'

A constitutional government for a fleet of AI agents

A governance framework — executive, legislature, and judiciary, implemented in code and documents — giving a large agent fleet accountability, formal decisions, term limits, and a single succession handbook so no knowledge is lost on rotation.

The problem: Managing a big fleet by hand becomes chaos: no accountability, no policy, a rulebook that rots.
Who it's for: Researchers exploring how to govern large multi-agent systems
The payoff: Every agent has a durable identity, every decision is recorded, recovery follows rules instead of heroics, and the law self-prunes via a 'librarian' that garbage-collects stale rules.

Markdown-as-law
Git
TypeScript
Claude Code

15 Dev Tooling

Session Resurrection Engine

Brings crashed AI sessions back with zero context loss

A recovery tool that durably records each session's identity and location, then restores the exact conversations and working context after a crash, reboot, or terminal-server failure.

The problem: When a multiplexer crashes or a machine reboots, live sessions and their full history vanish.
Who it's for: Anyone running long-lived terminal AI sessions
The payoff: Automatic capture when a session is born and deterministic resurrection with full history — no manual re-selection, no lost work.

Bash
tmux
tmux-resurrect
JSON registry

16 Healthcare AI

Self-Hosted Insurance Card OCR

Reads an insurance card from a photo, privately

An intake component that scans a photo of an insurance card and extracts payer, member ID, and plan details automatically to feed eligibility checks — running on infrastructure the clinic controls.

The problem: Hand-keying cards is slow and error-prone, and sending card images to third parties raises privacy concerns.
Who it's for: Urgent-care clinics and their intake staff
The payoff: Instant, accurate card capture with a fallback OCR engine, feeding real-time eligibility — less typing, fewer errors, more privacy control.

Document AI
Fallback OCR
Eligibility API
Python

17 Dashboards

Fleet Monitoring Wall

A live video wall of every AI agent at work

A web UI that streams live terminal sessions from many machines into one configurable grid — CCTV-style monitoring of an agent fleet — read-only by default, with secure, gated take-control of any single pane.

The problem: Operators need one place to watch dozens of agents and step in, without everything being writable by default.
Who it's for: Fleet operators and agent-infrastructure teams
The payoff: At-a-glance monitoring of dozens of agent sessions on one screen, a read-only-by-default posture, and on-demand single-pane control over an encrypted channel.

ttyd
xterm.js
tmux capture
mTLS

18 Agent Infrastructure

Acquisition Prospecting Platform

AI that researches targets and writes outreach that reads human

A platform that finds acquisition targets, researches each into a sourced profile, picks the best personalization angles, writes personalized letters and emails, then runs the multi-touch campaign with reply tracking.

The problem: Prospecting is hours of manual research per target and generic outreach that gets deleted.
Who it's for: M&A teams, search funds, and acquisition entrepreneurs
The payoff: Hours-to-minutes research, human-grade personalization, and an adversarial writer→critic→buyer-simulation loop that strips generic and creepy language before anything sends.

TypeScript
Bun
Claude (multi-agent)
HubSpot
Lob

19 Developer Tools

Autonomous Merge Gate

The pipeline is the reviewer — code merges itself only when every gate truly passes

A merge-decision system that lets orchestrator agents merge their own PRs, but only after querying actual review-thread state and CI status rather than trusting comment counts. It resolves resolved/outdated thread edge cases, waits for re-review after fix-pushes, and treats reviewer silence as 'not approved.'

The problem: Agents kept auto-merging unfixed code by counting comments, racing fix commits, or misreading outdated/blocked review threads as green.
Who it's for: Autonomous AI coding agents shipping to main without a human in the loop
The payoff: PRs now merge unattended with the same rigor as a careful human reviewer, eliminating false-green merges and silent blocks.

GitHub Actions
CodeRabbit
GraphQL review-thread API
CI status checks
Node.js

20 Agent Infrastructure

Agent Seat Rescue Daemon

Self-healing watchdog that revives dead and rate-limited agent seats without a human

A distributed watchdog that continuously verifies each agent seat is truly live, then automatically restarts rate-limited, dormant, or crashed Claude panes — with cooldowns and crash-loop detection so it never re-rescues a permanently broken seat forever. It judges success rather than age and confirms real liveness before acting.

The problem: Agent seats die silently or get rate-limited and stale monitors report them as 'LIVE' while no work happens, forcing manual revival.
Who it's for: Operators running large always-on AI agent fleets
The payoff: Keeps the fleet self-healing and continuously productive without the boss agent or a human babysitting restarts.

tmux
systemd
launchd
Claude Code
Bash
SSH

21 Agent Infrastructure

Fleet Config Deployer

GitOps for every box in the fleet — pull, don't push.

A pull-based deployment pipeline where each machine runs its own self-hosted CI runner that reconciles dotfiles, shell init, and Claude Code plugins from a central Git repo. Replaces brittle SSH sync scripts with idempotent, per-machine reconciliation that also manages agent plugins, not just config files.

The problem: SSH push-sync scripts silently drifted, never managed plugins, and leaked per-box overrides to the whole fleet.
Who it's for: Operators running a heterogeneous fleet of agent machines
The payoff: Every machine converges to its intended config and plugin set on its own, eliminating cross-fleet drift and accidental override leaks.

GitHub Actions self-hosted runners
Git
Zsh/Bash
systemd
macOS LaunchDaemons

Agent Infrastructure FCB

22 Agent Infrastructure

Fleet Credential Broker

One trusted source for every agent's tokens, never a plaintext file

A centralized credential layer that issues and rotates per-agent auth tokens from the OS keystore, isolating each agent's secrets so a switch on one machine never clobbers another's. It validates tokens against their real source instead of trusting fragile signals like process environ reads.

The problem: Plaintext token files, racing account switchers, and unreliable token-presence checks caused silent auth failures and one agent overwriting another's credentials.
Who it's for: Autonomous AI agent fleets that authenticate across many accounts and machines
The payoff: Every machine in the fleet authenticates with the right isolated token, with secrets kept out of plaintext and out of each other's way.

1Password Service Accounts
OS Keystore
systemd
Bash
tmux

Agent Infrastructure FDS

23 Agent Infrastructure

Fleet Doctrine Sync

One source of truth for what every agent believes right now

A propagation system that pushes updated agent skills, operating doctrine, and scoped stand-down orders to every running seat in the fleet mid-session, and verifies each agent actually adopted the new rules instead of continuing on cached instructions. It distinguishes global orders from scoped ones so a local pause never silently overrides a fleet-wide directive.

The problem: After a mid-session skill or doctrine refactor, half the fleet kept executing stale instructions and agents confused narrow stand-downs with global loop orders, going dormant for hours.
Who it's for: Operators running a distributed fleet of long-lived AI coding agents
The payoff: Every agent in the fleet operates on current doctrine within one refresh cycle, eliminating stale-instruction drift and accidental dormancy.

tmux
systemd
Claude Code
Bash
Git

Agent Infrastructure FEF

24 Agent Infrastructure

Fleet Egress Firewall

Network guardrails that decide which hosts an autonomous agent fleet is allowed to reach

A network-layer policy system that enforces which protected hosts and services each agent machine can and cannot reach, backed by firewall block rules and DNS/subnet-aware health checks. It treats egress as a security boundary so agents can't wander off to sensitive systems.

The problem: Autonomous agents with broad shell access will happily reach protected hosts unless the network itself stops them, and silent DNS or subnet failures can masquerade as agent bugs for hours.
Who it's for: Operators running fleets of autonomous coding agents across many machines
The payoff: Contains blast radius of a self-directed fleet while surfacing real connectivity faults quickly instead of misdiagnosing them as agent sleep.

pfSense
DNS resolution checks
tmux
SSH
macOS/Linux networking
LaunchDaemon/systemd

Agent Infrastructure PSL

25 Agent Infrastructure

PR Self-Healing Loop

Agents that fix their own PRs until the reviewer signs off — then stop.

A control loop that keeps each coding agent iterating on its own pull request in response to automated review feedback, waiting for the reviewer to actually finish before acting and halting the moment the PR merges. It treats reviewer silence as ambiguous rather than approval and uses a watchdog to prevent post-merge churn.

The problem: Agents were exiting remediation too early on unfinished reviews or looping forever after their PRs already merged, wasting compute and shipping unaddressed feedback.
Who it's for: Autonomous coding-agent fleets shipping to production
The payoff: PRs converge to a clean, reviewer-approved state autonomously without agents stalling early or spinning after merge.

CodeRabbit
GitHub API
Claude Code
tmux
systemd watchdog

Agent Infrastructure FB—

26 Agent Infrastructure

Fleet Boss — Agent Orchestrator

Routes the work, restarts the stalled, never touches the labor itself.

A supervisor agent that dispatches tasks to worker agent panes instead of doing the work itself, and auto-restarts rate-limited or stalled panes without human approval. It keeps a multi-pane Claude fleet productive by acting purely as a router and recovery layer.

The problem: An orchestrator that starts doing the labor becomes a bottleneck, and rate-limited or wedged panes silently stall the whole fleet.
Who it's for: Solo builders running large autonomous coding-agent fleets
The payoff: The fleet stays continuously working with self-recovery, while the operator's own context stays free for high-level decisions.

tmux
Claude Code
systemd
Bash/Zsh
Sub-agent delegation

Agent Infrastructure SIG

27 Agent Infrastructure

Self-Hosted Inference Gateway

Run your own GPU models so the fleet never depends on a single vendor

A self-hosted LLM serving stack that runs open models on private GPUs behind a token-secured endpoint, giving the agent fleet an inference backend it owns end to end. Handles auth, request sizing, and quota behavior so large and small calls route reliably.

The problem: Relying solely on external model APIs leaves the fleet exposed to rate limits, opaque 429s, and vendor lock-in for sensitive or high-volume work.
Who it's for: AI fleet operators who need local, controllable model inference
The payoff: The fleet gains a private, always-available inference path with predictable throughput and no third-party data exposure.

vLLM
Hugging Face
1Password
systemd
GPU serving
REST API

That's the short list. Want one of these — or something new — pointed at your problem?

Let's build it →