Projects

Journal analysis tools treat each entry in isolation, losing insight from patterns over time. Cloud LLM APIs also differ in availability and cost, requiring flexible provider routing.

Built a FastAPI backend with a RAG pipeline (sentence-transformers all-MiniLM-L6-v2, FAISS cosine search, prompt augmentation), multi-provider LLM routing, a BYOK token vault, and a ReAct-style agentic layer built from Groq API primitives (no LangChain) with 5 tools and observable planning traces. Evaluated retrieval with a golden test set and agent accuracy with a 10-case benchmark.

RAG retrieval: 0.80 precision@3, 1.0 MRR. Agent eval: 90% pass rate, 0.92 tool recall, 0.77 precision, 4.8s avg latency. Working multi-provider gateway with live demo, provider diagnostics, and reproducible eval harness.

Public ADS-B feeds expose raw aircraft positions but not interpretable signals about unusual behavior. An analyst can see thousands of points on a map, but not which aircraft deserve attention or why.

Built a FastAPI backend that ingests commercial and military telemetry, maintains in-memory aircraft state, and runs a sequential enrichment pipeline: Kalman filtering for state estimation, DBSCAN for pattern detection, and IsolationForest for anomaly scoring. The backend pushes GeoJSON to a Next.js + MapLibre frontend and exposes natural-language query, region summary, and anomaly explanation endpoints backed by Claude.

Built and deployed a full ML inference pipeline processing 11,000+ live aircraft per 60-second cycle, with Kalman state estimation, DBSCAN spatial pattern detection, and IsolationForest anomaly scoring. Captured 4 real Claude anomaly explanations from live flight data, including a US military helicopter (GRZLY71) executing a racetrack surveillance orbit. Implemented Fleet Analytics, on-demand feature vector display, and a collapsible Pattern Drill-Down. Fixed a state persistence bug that was silently discarding anomaly scores between non-scoring cycles. System runs continuously on Fly.io with CI/CD via GitHub Actions. Full technical write-up in CASE_STUDY.md.

AI coding agents fail predictably on multi-session projects: they declare features "done" before tests run, forget decisions across context resets, grade their own work generously, and drift from the original scope. None of these are prompt-quality problems — you cannot word-craft your way out of a structural failure.

Built infrastructure, not prompts. Gates are a project-defined YAML dependency graph enforced by shell hooks that exit 2 to block execution. A Gate Evaluator subagent runs in a fresh context, told "you did not produce this work," and blocks any gate scoring below 7.0. Three schema-validated JSONL memory types persist patterns, session events, and predicted-vs-actual calibration across resets. Every gate transition, block, and verdict is logged to queryable telemetry, and enforcement relocates to the git/CI boundary for non-Claude platforms.

Validated the core thesis by experiment: an agent scored its own work 5.5/10 while an independent evaluator scored the same work 2.5/10 — a 3.0-point gap the harness closes mechanically. 238 tests across 18 suites, all three recipes verified end-to-end. Dogfooded on two production projects, where a gate caught stub citation code an agent had marked complete and forced it to be rebuilt as real infrastructure before it could ship as technical debt.

The data that moves the AI, defense, and energy build-outs — DoD awards, EDGAR filings, NRC licensing, hyperscaler capex, export-control actions — is public but fragmented, slow to read, and disconnected from its market meaning. Serious investors don’t lack data; they lack the time to aggregate it and the tooling to connect a raw event to the security it affects.

Built a full production stack: a Next.js reader on Vercel, a FastAPI intelligence engine, and Supabase (Postgres + pgvector). A per-source scheduler pulls four live adapters (USAspending, SEC EDGAR, arXiv, NRC) through a retry/backoff fetcher with DB-level dedup and a circuit breaker; records resolve into a bitemporal entity-resolution graph; change-detection plus graph-grounded RAG generate a cached BLUF brief per desk; an eval gate checks for fabrication and grades each item’s attribution before publish. A daily cron ingests once and publishes all three desks.

Live end-to-end and publishing daily from live data. The entity resolver holds precision 1.0 / recall 1.0 with zero false links on a golden set, rendering each item’s companies as clickable entity chips and flagging cross-desk convergence — a company appearing on two or more desks — as the core signal. An interactive Convergence Graph makes the entity network visible, with the cited stories behind each connection and a federal-funding overlay. Payments are built but not yet wired to a processor; turning on subscriptions is the next step to public launch.

Embedding generation for SkillSwap's semantic skill-matching needed cheaper, faster inference on CPU without sacrificing match quality or requiring GPU hardware.

Exported the production sentence-transformer to ONNX via Hugging Face Optimum, applied INT8 dynamic quantization (88 MB → 23 MB, ~74% reduction), and swept batch sizes 1–64. Benchmarked p50/p95/p99 latency and throughput across PyTorch baseline, ONNX Runtime, and quantized ONNX configurations. Validated accuracy with cosine similarity against the PyTorch baseline.

ONNX + INT8 batch=32 achieved 2.9ms p50 latency and 602 req/s — a ~9× throughput improvement over PyTorch single inference. Model size reduced ~74%. Quantized embeddings maintained 0.962 mean cosine similarity vs. baseline. 17 passing tests with GitHub Actions CI.

Standard VAEs balance reconstruction fidelity against latent space regularity via a single β hyperparameter, but the impact is hard to reason about without hands-on experimentation.

Built encoder/decoder with configurable latent dimensions, trained across 6 β values, and measured reconstruction loss, KL divergence, and sample quality. Exported latent space interpolations and reconstructions as evidence.

Clear demonstration of how β controls the reconstruction–disentanglement tradeoff. Low β (0.1) gives sharp reconstructions but tangled latents; high β (10) gives smooth latent space but blurry outputs. 19/19 tests passing.

Full fine-tuning of LLMs is expensive. LoRA reduces trainable parameters by 95%+, but how does rank affect quality? Practitioners need empirical guidance for choosing configurations.

Applied LoRA to GPT-2 attention layers across 5 rank/alpha configurations on SAMSum (500 train examples). Evaluated each with ROUGE-1/2/L and BERTScore. Visualized training curves, ablation heatmaps, and before/after comparisons.

Rank 8 with alpha 16-32 captures most fine-tuning benefit at 0.65% of model parameters. Even rank-2 (202K params) substantially beats zero-shot. Methodology is model-size-agnostic and applies directly to Llama, Mistral, and other transformers.

Understanding RL requires building environments and agents from scratch — not just calling library APIs. How do tabular and deep RL methods compare on the same task?

Implemented WindyGridWorld (Gymnasium API), tabular ε-greedy Q-learning, and a DQN with experience replay and target network. Systematic comparison of convergence, sample efficiency, and solution quality.

Tabular Q-learning converges fast on small state spaces; DQN generalizes but needs replay buffer tuning. Full environment/agent separation following Gymnasium patterns. 24/24 tests passing.

Most practitioners use optimizer libraries without understanding the math. How do BGD, momentum, and Adam actually differ in convergence behavior across different curvature regimes?

Implemented all three optimizers and a feedforward neural network with full backpropagation in pure NumPy. Benchmarked on Rosenbrock, ill-conditioned quadratics (��=2–500), and MNIST classification. Visualized 3D loss landscapes and gradient norms.

Adam achieves ~93% MNIST accuracy vs SGD ~85%. Condition number study shows Adam effectively reduces effective κ. He initialization critical for ReLU networks. 29/29 tests passing, zero external ML dependencies.