Selected work,
in the open.

An 18-skill agentic operating system for the modern job search. Not a chatbot — an actual operating system. It manages the full lifecycle: finding roles, qualifying them, applying, prepping for interviews, debriefing after calls, and negotiating offers. Built on Claude Sonnet 4.6 + Next.js 15 + Supabase, with persistent state across sessions and a self-improving playbook that learns from every correction.

Nine quality gates sit between the LLM and the user — preventing the failure modes that make raw GPT-on-resume tools dangerous: resume fabrication, comp-math errors, persona mismatch in prep docs, fabricated experience claims. The architectural rule: LLM downstream of parsers + provenance + coverage receipts, never raw string-to-output.

Co-founded 50/50 with Zach Berenzweig as a lifestyle business — not optimizing for raise or exit. Binary 90-day gate: 10 paid customers at list price by July 31, 2026 determines kill-or-scale. Launched April 21, 2026 with a 9/9 launch checklist. PostHog telemetry live April 23. Voyage AI embeddings on paid tier. Sentry-bridged structured error logs. Full GTM plan, partner alignment memo, pricing strategy, and channel ranking are part of the showcase above (slide 07).

A paid exam-prep product for Anthropic's Claude Certified Architect (CCA-F) exam, built solo end-to-end: curriculum, question bank, quiz engine, and checkout. The core IP is the STACK Diagnostic™ — a five-step method (Spot, Trace, Assess, Classify, Kill) for solving any agentic-systems scenario question in under 60 seconds, taught across 8 guided lessons before the learner ever touches practice mode.

638 practice questions across 5 weighted domains (D1 27% · D2 18% · D3 20% · D4 20% · D5 15%), a 60-question timed mock exam matching the official question count, flashcards, and an exam-day cheat sheet — all generated from versioned source banks (legacy scenarios, pattern variants, official samples, community imports) rather than hand-written one at a time.

Monetized via Whop checkout at a single $49 "Full Access" tier — curriculum + app + private community — with a free public marketing page and a signed-cookie gate protecting the paid app. Content is fully rebuild-safe: every generator run re-derives the question bank from source files, so nothing is hand-edited into a build artifact.

A conversational right hand built from one instruction — "you never navigate, you talk, and the screen follows." Voice and typing produce identical turns; the reply is generated once and rendered twice, full to the screen and shortened to the mouth. Behind it sits a 24-tool registry that reaches a work ledger, a build agent, a coding agent, mail and Slack, with a local 14B open-weights model on-device for the lane that has to answer in about a second.

Two lanes, decided in code, never by the model. A recognized lookup takes the fast lane; a real question goes deep — the local model clarifies and mirrors a brief back first, and only on an explicit go does it fire a single remote consult, rather than a fat tool loop that invents from board titles. Writes are objects, not sentences: a mutating phrase builds an Artifact {tool, args}, and approving it calls the registry with the stored arguments and no model in between. Destructive writes are gated; the rest of the notepad is free.

The operational discipline is the point. Code runs from a detached worktree with its own venv and state lives outside every checkout, because the daemon twice served a branch nobody intended from a shared one. The deploy asserts which code is running — lsof on the process — not merely that something answers. And a hey rewind codeword pulls the real transcript out of SQLite before anything is diagnosed: both times it has run, the transcript held a worse bug than the one I noticed.

A two-layer, version-controlled brain: every AI surface I use — Claude Code, Claude.ai projects, Cursor, local Ollama models, the Atlas agents — bootstraps from a single git repo. Lessons captured during work graduate to rules. Drift is reviewed every Saturday at 8am CT by an automated coaching script. The brain compounds; nothing slips out the back.

Architecture: contexts (per-project knowledge), workflows (11 named procedures), templates (PR descriptions, decision docs, incident reports), vocabulary (phrases, glossary, anti-patterns), strategy (10-year plan, three planks, weekly commitments), lessons (capture → promote → archive). A rebuild.sh script compiles 8+ adapters and distributes them to downstream tools. Gitleaks pre-commit. iPhone-editable via Working Copy.

Phases 1–4 complete (Foundation, Protocols, Automation, Integration). 190+ lessons captured · 31 in the last week. Includes prevention layers built in real time: never-silent-delegation rule, MCP preflight, atlas-pickup-watch — each derived from a specific incident, each preventing recurrence.

An autonomous dev agent that runs on owned M3 Ultra hardware. Renamed from atlas-direct (May 2026); cloud-triggered worker model retired in favor of a local manager + on-demand worker split with hot-swappable inference backends. Primary inference: Rapid-MLX serving Gemma 4 26B-A4B MoE 4-bit at ~70 tok/s. Fallback: Ollama with llama3.3:70b. Cloud-API path opt-in, OFF by default.

Phase 47 replaced single-worker + 10-second inbox polling with four KeepAlive lane workers (pcm · sfdc · atlas-d · research) communicating with the manager over an in-process event bus. Dispatch latency dropped from ~5s avg to ~50ms — 100× improvement. Per-lane crash isolation, real-time mission-control UI on 127.0.0.1:8766, heartbeat-based liveness.

Intake: Linear webhook → lane inbox → watchdog file watcher → worker. Approval gates via Linear comments for external writes (SF DML, HubSpot mutations, mail send); internal-only changes ship autonomously. Operating principles locked 2026-05-16: honest, fast, methodical dispatch, maximum autonomy. Marginal compute cost: ~$0.

A local autonomous coding stack running on the M3 Ultra under my desk. FastAPI service. Aider as the primary coding interface; headless Claude Code as fallback / review pass. Redis queue. Per-task model selection with batched loading to minimize swap thrash on 96 GB unified memory.

Strict compliant model stack: Mistral · Meta · Microsoft only — US/EU origin enforced at the router. No Qwen. No DeepSeek. Native Ollama (never Docker — Docker'd Ollama loses Metal GPU access). Cursor connects via a private tunnel.

16 Signal OS task specs sit in the queue as structured markdown with goals, acceptance criteria, expected output. Atlas3 consumes them and generates the code. 66 files, ~1,491 lines of Python at 0.1.1.

A production-grade multi-agent platform running on local hardware. Three core agents — Alpha (Salesforce / CRM / Apex), Beta (code, scraping, build tasks), Gamma (R&D experiments) — plus a dedicated Delta coding agent. BullMQ on Redis for job orchestration. Postgres + pgvector for semantic memory. AI router with complexity-based dispatch (0–100 score; threshold 70 routes to Claude API; below stays local).

Single REST + WebSocket + mDNS gateway. ComfyUI for local image generation, prompted by Beta on creative tasks. Operator shell commands wrap the gateway for invocation, review, and curation. The whole thing runs while I sleep.

Twin sandbox copy in bot-army. Both have Alpha/Beta/Gamma, gateway, Redis + Postgres, security policy, runbook, skill audit framework. The lane lock is non-negotiable: Alpha owns Salesforce, Beta owns code/scrape, Gamma owns experiments. Cross-assignment is the failure mode the architecture exists to prevent.

A from-scratch training curriculum teaching a non-technical RevOps team how to actually use Git and GitHub — not conceptually, but against the real, live company repository they work in every day. Ten modules run the full arc: why version control exists at all, reading the actual repo structure, branches and worktrees, commits, push/pull/fetch, pull requests and reviews, and how Salesforce CI validation and deployment actually work underneath a merge.

Every screenshot is a real capture of the live environment — not a mockup — pulled from a driven headless-browser session against production. Closes with a glossary and a scored quiz so the team can self-certify before touching a real PR.

Shipped through the same PR-and-CI pipeline it teaches: merged via a reviewed pull request into the private company repo, with a GitHub Actions workflow that redeploys it to the internal Pages portal automatically on every merge to main.

A reusable, config-driven audit primitive that produces, in five minutes, the deliverable Big-Four firms charge $150K–$500K and three to six months to assemble: maturity scorecard, severity-ranked findings, remediation playbook, and AI augmentation roadmap. Same code base for every engagement; one YAML config changes per customer.

Built and immediately run against a live B2B SaaS production environment + partial sandbox + HubSpot portal. 104 findings (22 P1, 18 P2, 63 P3) surfaced — including a previously-unknown twin-label collision the lesson-bound detector caught without any vendor-specific code. The detector generalized beyond the original incident; that's the architectural win.

The audit is the lead. The AI augmentation roadmap — six categories (detect / repair / maintain / augment / audit / decide), three horizons — is the retainer pitch. Defaults to local-first inference for data-privacy reasons; cloud allowlisted to providers with signed DPAs.

Design guidance handed to a coding agent as prose is advisory, and the agent drifts. shine makes the tokens and the gates the enforcement instead of the instructions: one DTCG token source emits nine platform targets — CSS variables, a Tailwind v4 theme bridge, artifact CSS, Python, email HTML, Google Apps Script, Office, and the Salesforce triple — so a value cannot be right in one surface and wrong in the next. A shadcn-compatible registry is generated from the same source, so npx shadcn add can't drift from it either.

Knowledge is retrieval, not context. A 49-pin corpus of real design-system source — shadcn, Radix, Base UI, Carbon, Ant, MUI, React Aria, Fluent, Polaris and more, every SHA pinned — sits on disk and is queried with ripgrep, costing zero tokens until a match returns. A 117-template catalog means a screen starts from a real, opened template rather than an invented layout; only a 255-line index stays resident out of 4,611 lines of authority.

The part I'd defend hardest is that every gate is proven by being fed a known violation. The self-test doesn't check that hooks are configured — it hands each one a violating write and asserts it blocks, on both editor surfaces, in both hook contracts. The contrast gate screenshots an element's painted box and compares text against every background pixel, because a declaration-reading check passes happily on text over a gradient. Composition checks exist for a blunt reason recorded in the source: an earlier audit had everything green, zero accessibility violations, worst contrast 6.85:1 — and the screen was still wrong.

A conductor, not another worker. Atlas6 keeps a durable ledger of every open work thread and decides who should touch each one — then enqueues the existing Atlas5 build worker rather than competing with it. FastAPI + SQLite on the Mac Studio; every thread carries a status, a next action, an executor, an autonomy class, and its evidence, and every mutation appends to an event log.

Routing is rules-only — no LLM in the dispatch path. A "Path-0" matrix escalates by cost of being wrong: local triage, then an Atlas5 sandbox build, then a frontier consult, then a human gate for anything touching production or leaving the building. Skills are typed async Python declaring what they read and write, so the runtime gathers only the state a skill actually asked for — Linear and Salesforce are opt-in, never implied.

The interesting part is the honesty machinery. Ten codified invariants include fail-closed delegation (worker health check fails → human gate, never a silent build) and a pipeline that cannot report completion is presumed broken. One resident model, one Atlas5 ticket in flight, no fake parallelism. An Auth Sweep ritual encodes "present ≠ loaded ≠ probe_ok" after a real incident where a credential sat in an env file that launchd never sourced — and the repo's own SSOT carries a full written stall diagnosis, banner included, warning readers not to trust the green checkmarks above it.

A vertical voice-agent platform for tow and roadside-rescue companies: a LiveKit Agents worker answers the call, walks a fixed eight-beat intake — safety first, always — extracts sixteen slots as the caller talks, and streams them live into a dispatcher cockpit where every field is a tri-state pill showing captured, in-progress, or still missing. Deepgram Nova-3 for speech, Gemini Flash-Lite at temperature zero, ElevenLabs Flash for voice.

Tenants are packs, not branches: display name, greeting, voice id, service area, hours, an ASR keyterm list that teaches the recognizer words like flatbed, winch and mile marker, a lexicon of local landmarks and yards, and a per-action declaration of which slots must be filled before that action is legal. Nine agent tools sit behind a secret-gated Node gateway, one endpoint each. The beat schema explicitly forbids reordering mid-call, because a script that reshuffles under pressure is a script that skips the safety question.

The design conviction worth stealing is delivery honesty: both SMS transports re-poll status after sending and throw on undelivered, because carriers accept long-code traffic and silently drop it — so the agent is structurally unable to claim a text arrived when it did not, and falls back to email instead. Stated plainly: this is two days old and a lab, not a product. The worker runs, a live session transcribed real speech and spoke its greeting, and a job record was written through the tool gateway — but the full conversational loop has not completed end to end, stopped by a depleted model billing balance rather than a code defect. No phone line is wired, and the second tenant is configuration only.

A real-time video-avatar interviewer running two insurance interviews: a first-notice-of-loss motor claim intake, and a New Business Auto interview that verifies the four things an auto quote is actually rated on — vehicles, usage, garaging, drivers. Both bots share one engine behind a registry; adding a third is a registry entry, a prompt template, a question bank, and a panel schema. Zero npm dependencies, no build step.

The engineering is in the guardrails, not the face. Three verification questions are asked verbatim, in fixed order, one per section, with a uniform neutral acknowledgment — because a fraud-signal question that varies in wording or warmth stops being comparable across applicants. She may never quote a premium, estimate a rate, or promise eligibility. A scripted simulated-caller harness runs 65 test personas and scores ten discipline invariants per run — parroting, looping, off-set questions, unprompted reference numbers — at zero avatar minutes.

Two failures worth the writeup. Injecting a per-session prompt replaced the whole prompt object and nulled the agent's tool ids, so she narrated sending a text she had no means to send — three correct fixes in a row could never have worked. And on the eval suite, the vendor's newer and 21% more expensive model scored 4/12 against the older model's 8/11: every signal short of running the suite said upgrade. Face failure is handled by a three-tier server-side cascade — Anam, then LiveAvatar keeping the same brain, then audio-only with an apology banner.

The public demo estate the sales team runs live in front of prospects. Rather than a slide about how voice risk assessment works, a buyer clicks through a realistic quote, claim, or intake journey on an invented carrier — Affinity Insurance in the US, a Czech-language sister brand, Affinity Bank for a scam-prevention payment pause — hits a genuine Clearspeed voice questionnaire mid-flow, and lands on a results dashboard. Eleven live production questionnaires are embedded across the site; the brands are fiction, the assessment is not.

Breadth is the point: 34 routed pages across seven lines of business, each with its own quote and claim chain, plus workers-comp premium audit and return-to-work paths. A separate government and security set covers five public-sector scenarios — travel authorization, unemployment-insurance certification, food-assistance screening, provider enrollment, retiree benefits — each a standalone page with its own embed. The whole site ships in nine locales including right-to-left Arabic, with per-locale fonts, locale-prefixed URLs and generated hreflang alternates.

Two pieces of machinery behind the demos. An avatar mirror serves the entire insurance site a second time with the questionnaires swapped for a video interviewer, deliberately leaving the original live so a rep can run both side by side. And a gated library of customer demo recordings runs two independent gates — a work-email lead capture that writes to Salesforce through a client-credentials Connected App with dedupe, and a staff-only path requiring a company address plus an emailed code — where a CRM failure never blocks the download. An hourly health probe samples the avatar tier and appends results to a monitoring branch; the primary tier was only promoted after a 50-hour study came back clean.

A demo factory. A script goes in as ordered segments, each one a separate text-to-speech call across two providers and 1,300+ voices with per-segment pause control; out comes a stitched narration and then a finished 1080p video of the Clearspeed assessment player, rendered frame by frame in headless Chromium and muxed with ffmpeg. Claude structured outputs clone a whole project into another language — segment text and the player's own interface chrome together — so a localized demo isn't a separate build.

Timing is derived, never hand-authored. Every segment is synthesized, normalized, and measured with ffprobe, and the measured durations generate the question rows, columns and cues — which is what makes a production-format demo possible at all, where the same question set is asked twice but only the second pass is scored, so cue index, row index and column index deliberately stop matching. Sixteen standard system-audio components ship in every export, voiced by that demo's own narrator and cached so a warm build costs nothing.

The hard-won part is publishing. The video host has no usable API on this account, so upload is a headless drive of its own uploader widget — and that widget has no idempotency key and cannot swap the video inside an existing player, so every upload mints a new one. Auto-upload is therefore first-publish-only: a republish keeps the existing player, and replacing it is an explicit per-publish choice that records the superseded id and knowingly stales every share link in circulation. Publish is an upsert keyed on the source project, guarded by an in-flight lock, and its test harness injects stubs through the require cache so the real code paths run unmodified against six named failure scenarios.

A front end that turns a real executive calendar into per-meeting intel packets: likely questions already answered, committed versus delivered, live blockers, what to watch, and what changed since you last met. The roster is a real working week — 22 meetings, only five worth a kit — and the non-targets render as plain rows on purpose, because the density is what tells you where the prep actually matters.

The discipline is enforced in code rather than asserted in copy. A sanitize pass drops any unsourced quantity, drops sections left empty, and always banners a stale pack — and the rule is deliberately scoped so money, percentages and magnitudes need a source while a date or a day count reads as prose. That precision was earned: a cruder digit scan had silently deleted an entire board kit, and that regression is now a test. Every kit renders in four honesty states, including one where a named source failed and the items it fed are visibly removed rather than quietly thinned, and one where unevidenced sections are omitted entirely — silence, not filler.

Around that sit a stateless HMAC email gate with an emailed code and a live expiry countdown, and a hands-free voice mode that speaks a briefing through a server-side proxy so the synthesis key never reaches the browser — with a text-preparation layer added after a real listener heard a month abbreviation read as a name and the interface chips read aloud. Accessibility got measured, not claimed: disclosure rows are buttons with sibling links so opening a source can't toggle the row, the evidence panel stays mounted so its relationship always resolves, and a contrast finding here pushed a brand hover colour upstream from 4.43:1 to 5.01:1 — it had been failing normal-text AA by seven hundredths.