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.

Take an inexpensive phone, unlock it, and lock it down so it no longer behaves like a phone — it boots into a landscape home shell with a curated catalog of offline educational games and nothing else. Tap a tile, hear a warm voice, and watch the idea become visible.

Star Learner — Garden Explorer’s current farm layout on the landscape kiosk.

Ant Explorer — guide a worker through a living leaf-cutter nest; collect twelve knowledge stars with short ant documentaries; the colony balances itself through caste homeostasis.

Ant Explorer — enter the colony, meet the castes, and see how the nest runs as a living system.

Garden Explorer — plant, water, grow, and harvest in a seasonal farmyard; animals, bugs, and knowledge stars with narrated educational clips.

Garden Explorer — a calm offline garden where chores and stars teach how plants and animals live.

Solar System Explorer — fly a spaceship or tour a narrated orrery, then open Learn-more clips from the Sun through the outer system.

Solar System Explorer — plot, burn, coast through the belt, and park in orbit with clip cards she can open herself.

Math Explorer — every number is a set of cubes she can count; narrated tutorials for + − × ÷, practice that re-counts mistakes, and story games (chickens, trains, coins).

Math Explorer — block math you can see, touch, and hear.

Language Explorer — bilingual English/Spanish reading and writing: sentence matching, books, alphabet tracing, and voice-to-writing when the hub is reachable.

Language Explorer — words she can hear, tap, spell, and write on the console.

Built in Godot 4.3 for a landscape Android appliance: catalog-driven kiosk shell, per-game APKs, baked ElevenLabs narration, and the stars format — short educational clips as glowing rewards inside each world. Full walkthroughs, screenshots, and sample clips live on the public portal.

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.