I build self-improving agent systems.

Problem

A ReAct Text-to-SQL agent with a windowed execution-accuracy monitor. When the agent's success rate drifts down, the system injects targeted few-shot examples from a teacher model and re-checks recovery by executing the SQL against a contamination-free held-out split. No fine-tuning. Improvement is verified by running the query, not by a judge model.

What I did

• 10% to 33% accuracy on 30 hard Spider queries. The repair loop closes on the agent's own execution signal, so nothing external has to notice the drift.
• McNemar p = 0.016. 7 queries improved, 0 regressed.
• Verified by execution, not a judge model. Recovery is measured by running the SQL against a contamination-free held-out split.
• No fine-tuning. The correction is targeted few-shot injection from the teacher at the moment drift is detected.

Problem

A reproducible research harness for teacher-guided reasoning transfer on finance reasoning benchmarks. A teacher model supplies per-task guidance that lifts a student model's reasoning, with the gain measured against a no-plan baseline under a pre-registered protocol and confirmed by replication on a second serving stack.

What I did

• +5.21 pts over a no-plan baseline. p = 0.031, pre-registered n = 40, 95% CI [+0.47, +9.76].
• Replicated at +6.0 pts on a second serving stack. p = .001, 22 wins, 6 losses.
• Pre-registered protocol. The metric and sample size were fixed before running, so the number is a test rather than the best slice of a search.
• 11.2K lines, 217 tests, 105 commits.

Problem

Amazon and Together AI gave 10 teams a pretrained code-gen model and one job: make it resist prompt-injection and jailbreak attempts without over-refusing legitimate coding help. Teams went head-to-head in adversarial tournaments.

What I did

• Built the attack taxonomy. Python vulnerability classes and adversarial patterns. Drove how the team generated training data across the project.
• Agent-driven attack simulations. Attacker agent probes the defender, logs what gets through, pushes those failures back as training data for the next round. Cut hand-curating attacks out of the loop.
• Adversarial corpus at scale. The attack-side data that fed the fused defender model and moved our Tournament scores.
• Team placed 1st in Tournament 2, 2nd in Tournament 1, against Claude-3.7 Sonnet and CodeLlama-70B baselines.

Problem

Different agent roles in AutoUnify's coding-agent pipeline needed different model behavior. Worker agents needed strong code generation and task completion. QA agents needed strict validation and deterministic output. Using the same model + prompt everywhere was unreliable, and prompt/parameter changes were landing in production without a way to tell whether they actually helped.

What I did

• Role-specific model selection: scored models per agent role (worker vs QA) and found a model great at code gen over-refuses on QA, and vice versa. Standardized temperature, top-p, max tokens, and schema strictness per role, cutting manual prompt-tuning effort by ~25%.
• Evaluation infrastructure on FastAPI + PostgreSQL. Stored benchmark runs, prompt versions, model outputs, p50/p95 latency, cost per 1K tokens, and schema-validation results, exposed through REST APIs that orchestration logic used to pick a model + config per role.
• Observability for model selection: p50/p95 latency, cost/1K tokens, quality score, schema-adherence rate, and regression status logged per benchmark run.
• Regression-safe CI/CD via Pytest, lint, JSON-schema checks, and benchmark thresholds in GitHub Actions. Blocked degraded configs before merge and improved merge velocity by ~20%.

Problem

U.S. jurisdictions trying to improve housing affordability have no good way to know which policies fit their local context. This system builds that match: given a jurisdiction's demographic and economic profile, predict which of the three policy classes it is likely to adopt.

What I did

• LLM + RAG prediction pipeline over ChromaDB (6,809 chunks, all-MiniLM-L6-v2 embeddings). Two-pass retrieval: k=15 first pass, k=3 reranked. Llama 3.3 70B via Together AI with Groq fallback. Three policy classes: Density Bonus, ADU, Affordable Dwelling Unit Ordinances.
• Community profile system segmenting jurisdictions into five types (rural low-income, urban high-cost, college town, suburban growing, others) to ground predictions in local context.
• BPS data integration via flat-file parsing of the Building Permit Survey. Wage data sourced manually via BLS where APIs returned null.
• 95 tests passing, BAD_COMPARABLE detection implemented. FastAPI backend on LangChain with evaluation across demographic slices.
• Eval results (v1.2, query-level test set, n=18): 86.67% accuracy on the 15 classifiable queries (3 ambiguous excluded), 88.6% macro F1 across the three policy classes. Per-class P/R/F1: ADU 100/100/100, Affordable DU 83/100/91, Density Bonus 100/60/75. Ambiguity-handling pass rate 100%, evidence-backed rate 77.78%.
• Known gap: retrieval recall@k not yet formally measured; evidence-backed rate is the current grounding proxy.

Problem

50+ teams, 36 hours, a brief to build healthcare infrastructure. We chose autonomous microservices to prove we could decompose and reassemble a real workflow under time pressure.

What I did

• 6 autonomous microservices coordinating via JSON-RPC 2.0, deployed to AWS EC2 and validated against 12 end-to-end bookings.
• 4th place + honorable mention among 50+ competing teams in 36 hours.

Problem

Employee onboarding and permission ops were manual, slow, and error-prone. I owned three FastAPI apps replacing the worst offenders.

What I did

• Shipped 3 FastAPI apps with role-based workflows. Saved 200+ hours/month across 400+ employees.
• Cut response times from 30s to under 10s via Redis caching + async I/O while handling 1K+ daily interactions.
• Observability dashboards for latency, error rate, throughput across all three services.