Dylan McCapes

A production clinical decision-support platform I designed and built end-to-end — backend, web, mobile, and the retrieval brain in between.

An async FastAPI backend on PostgreSQL + pgvector, a React/TypeScript web client, and a React Native mobile app. Clinical answers come from a hybrid retrieval layer — BM25 + ANN embeddings over a unified medical knowledge graph that fuses SNOMED concepts, clinical guidelines, and a custom "Ethos of Health" patient-state model (baseline integrity, chronic-baseline mode, and per-diagnosis stability "stack levels").

Built HIPAA-forward from the start: encrypted logging, token-gated B2B routes, and auth on every sensitive endpoint. I owned it from architecture through deployment.

Demographics get argued endlessly, but almost nobody keeps score. Conflux Atlas treats religious shares and migrations as claims that settle later — every source carries a Beta trust posterior that only moves when reality lands a hit or a miss.

Narrated alpha film (~3.5 min, sound on): a real Natural Earth map of the desk — Morocco to Iran — where fill brightness is citation confidence, outlines mix Muslim/Christian/Jewish RGB, and migration arcs fire through five historical beacons from the 1923 Lausanne exchange to the Syrian Civil War. The narration says the honest part out loud: dim fills are missing data, not a rendering bug.

Underneath is an evidence graph with connascence-typed edges — structural (shared methodology discounts corroboration), conceptual (complement and conservation constraints), co-variance (FDR-gated hypothesis edges), temporal (shock windows) — and a settlement loop: recording a claim is free; only settled outcomes move source trust. Pre-registered backtests (fixed 1975 cut, Winkler interval scores) and a sparsity→simulation bridge that backfills the thin pre-1920 record with honestly widening bands.

LLMs appear only as heuristic management infrastructure: schema-constrained local models propose event attributions and conceptual couplings, deterministic verifiers gate every write, and the LLM itself carries a trust posterior like any other source. Built in an overnight sprint on components proven in my other systems — the Beta-Bernoulli core from the MCP Learning Engine, connascence and graph lifecycle from OGrE.

A locked-down phone console for a six-year-old: tap a tile, hear a warm voice, and watch the idea become visible — colonies that balance themselves, a solar system you fly through, math made of countable blocks.

Ant Explorer explainer — enter the colony, meet the castes, and see how the nest runs as a living system. Homeostasis walkthrough — surplus and shortage pull the colony back toward balance, with the feedback loop drawn as it happens. Solar System Explorer explainer — a little tour of the Sun and its planets, with clip cards she can open herself. Math Explorer explainer — block tutorials for + − × ÷, story games (chickens, trains, coins), and practice that re-counts wrong answers instead of just marking them wrong. Math Explorer walkthrough — the launch intro tour, a block tutorial, practice, and the story games end-to-end.

Built in Godot 4.3 for a landscape Android appliance: a catalog-driven kiosk shell, per-game APKs, baked ElevenLabs narration with an OS-TTS fallback, and explainer videos playable from gold ▶ chips under each tile. Ant Explorer models caste roles and nest homeostasis; Solar System Explorer is a narrated flyer with offline planet clips; Math Explorer makes every number a set of cubes she can count.

Point it at a codebase you've never seen and it tells you how the thing actually works — and where the bodies are buried.

A hybrid-RAG pipeline (ripgrep + embeddings) runs a probe → gap → report loop across ten dimensions of a system — data layer, APIs, UX, security, testing, and more — with timestamped human-in-the-loop governance gates, dual-written logs, and per-run metadata.

The real test: executives wanted to know whether two sister companies' shower-controller programs (Moen and Aqualisa) could be merged. Instead of months of manual manager review, FullMetalPacket analyzed every codebase and produced reports that spoke for themselves — the decision was made not to merge.

A code-intelligence tool tuned for Android Studio projects — index a repo, then actually talk to it.

The indexing pipeline goes skeleton → dependency graph → LLM enrichment → embeddings, then answers in two modes: an engineer-mode chat for digging into code, and a product/architect mode that writes phased design docs. It also exposes fast no-LLM paths — direct grep and semantic search — plus an Android-docs fetcher, dependency-graph summaries, and governance gates on the expensive phases.

It's the middle link in a lineage: the FullMetalPacket idea, sharpened for one ecosystem, on the way to ProScope.

"Vibe-coding" with guardrails. Describe a feature in plain English; ProScope turns it into phased plans, plain-English strategy docs, and reviewable git diffs — and never writes anything without your approval.

Every step ends at a Proceed / Question / Abort checkpoint, so a founder or product lead stays in control while the model does the heavy lifting. It runs fully locally on Ollama with GPU-probed model tiering (7B / 14B / 32B), is language-agnostic (Python, TypeScript, Go, Rust, Kotlin, Swift, and more), and offers two front ends over one backend: a pure-PyGame "mission control" GUI and a matching CLI.

It ships a deterministic end-to-end test harness that drives the full plan → strategy → implement → commit loop with a scripted stand-in for the model — so it runs in seconds with no Ollama and no network.

An engine with one job: keep score. Modules emit claims, reality settles them, and the engine bumps exactly one Beta posterior per module — then Thompson sampling decides who gets believed. It never reads a claim and never looks inside a module.

Narrated demo (~3 min, sound on): a distributed research project where every module is owned by a different researcher on their own machine — a plain sequencer feed, a pipeline with its own internal caller ledger, a full agentic council, and a noisy preprint firehose whose trust gets ground down. Mid-run a partner institution's knowledge graph joins over the MCP bridge at Beta(1,1) and earns its rank live.

The contract is two rules. First, the engine never judges implementation — a module can be a one-line feed or a full agentic council with debating seats and influence normalized to sum to one; internal sub-ledgers (caller versions, journals, council seats) are the owner's own business, and the engine sees one posterior per module. Second, a module is a process behind MCP — a collaborator's hardware can host one, joining at a uniform prior with no configured authority, earning weight purely from settled outcomes.

Everything in the demo is computed live: the posteriors and uncertainty bands, the sub-ledger weights folding into emitted confidence, the council's influence math, and the newcomer's cold start. The same architecture runs my production trading-research system — the engine stays small and boring; the intelligence lives at the edges and has to earn its place.

What should a system remember, and what should it let go? OGrE answers with the geometry of chaos — a real-time PyGame simulation of a knowledge graph that grows, decays, forgets, and resurrects.

Narrated walkthrough (~2.75 min, sound on): opens on the animated Lorenz attractor, then the local 14B agent ingests work items while OGrE weaves 5D-connascence edges and the Lorenz GC evicts → forgets → resurrects from the FIFO log. Voice + on-screen subtitles explain each phase.

Work items are ingested by a local Ollama agent (qwen2.5-coder 14B, GPU-tiered to fit 12 GB VRAM) that enriches each into concepts and importance. Opportunistic Graph enrichment (OGrE) weaves them together with 5D-connascence edges — structural, conceptual, temporal, co-occurrence, and co-variance. Vitality decays over time but propagates along edges, so densely re-referenced clusters reinforce each other into stable attractors.

A Lorenz-attractor garbage collector (built on my provenance-engine package) maps every node into the chaotic system and classifies it by which wing its trajectory settles into — KEEP / REVIEW / EVICT. Evictions fall into a 100-item FIFO log; an agent searching the past walks the live graph first, then the log, and resurrects anything still referenced. The whole lifecycle renders live and records straight to video.

An education engagement for an e-commerce company: take a team from "we use AI tools" to "we understand the systems underneath them."

The running example is a 10-"book" advertising knowledge assistant that grows across the course — staged-reduction RAG, an MCP server exposing tools, an agentic loop, and a "score-keeping" (Bayesian) belief-update layer that decides what to trust. It ships a fully offline, pre-built HTML reader (markdown + visual explainers compiled by a Python builder) alongside runnable RAG / MCP / agent code.

I delivered a live 90-minute foundations session from it; it's scoped as a potential multi-lesson series.