Staff ML Engineer / Scientist · LLM & Recommendation Systems
Sugeerth Murugesan
I build and evaluate LLM recommendation and agentic systems that survive production.
Retrieval, ranking, and the agentic layers that act on them — productionized and A/B-tested, not just prototyped. Plus the post-training and evaluation behind them.
150M+Users in production
20+Open-source projects
8Peer-reviewed papers
PhDCS · UC Davis
Every project below links to running code.
Experience snapshot
Experience
-
Staff ML Engineer / Scientist — Intel (2020–23) / Intuit (2024–present)LLM-powered recommendation & agentic-AI systems in production; DeepInsight real-time ML analytics — Kafka · Flink · Kubernetes · C++/Go/Python
-
Research Engineer — Samba TVCo-creator of Sambavision — applied ML/CV research shipped into product
-
Research Intern — Adobe ResearchDeepCompare, interpretable deep learning — patent + IEEE CG&A
-
Graduate Fellow — Lawrence Berkeley National LabComputational Research Division — large-scale scientific data + ML
PhD in Computer Science, UC Davis · Research Associate, UC Berkeley / LBNL
Hiring for LLM / RecSys / agentic-AI roles? Start with the
five featured builds, skim the
recent writing, or just
email me — I reply within a day.
LLM Post-Training
- DPO
- GRPO
- RLHF
- LoRA / QLoRA
- Distillation
Recommendations
- Two-tower retrieval
- Ranking
- ANN search
- A/B testing
Agentic Systems
- LangGraph
- Multi-agent
- Tool use
- Observability
Evaluation
- LLM-as-Judge
- RAG eval
- Reward hacking
- Eval harnesses
Serving & Infra
- vLLM
- SGLang
- DeepSpeed
- FSDP / DDP
- CUDA
About Sugeerth Murugesan
About
Sugeerth Murugesan
Staff ML Engineer / Scientist · LLM & Recommendation Systems
I build, train, and evaluate LLM and recommendation systems — post-training, agentic pipelines, retrieval, and the infrastructure behind them.
Currently
Production systems & open experiments
- Shipping LLM recommendation + agentic systems in production
- Open experiments: AgentDiff for agent evaluation, GPU Training Lab for post-training, ARES for RAG evaluation
- Measuring what moves quality and cost — and publishing the result, including the null ones
Connect & Explore
Research & Industry
01
Featured Work
Five builds, each with running code: a prompt tool that runs in your browser, a diff for AI agents, a ~25-notebook post-training lab, a self-improving training loop, and a live graph of Bay Area traffic.
Keystone project · live now
Built for people who won't write long prompts: tap once and a complete
expert prompt is on your clipboard, ready for ChatGPT, Claude, or Gemini.
Type a few words instead and a 7-dimension rubric scores, grades, and
rewrites your prompt in real time — then hand it to one of
three client-side agents (classify → critique → rewrite → verify)
that render live step traces. Everything runs in the visitor's browser:
a pure-JS heuristic engine on any device, Hermes-3 / Qwen2.5 on WebGPU
(via WebLLM) when you opt in. No server, no API keys, $0 infrastructure, forever —
the same thesis as my agent-evaluation work: useful agents need good scaffolding
and verification, not expensive infrastructure.
Launch the live app →
one tap = expert prompt copied · nothing to install · works on phones too
Agent Evaluation · Open Source
AgentDiff — git diff for AI agents
MIT · no dependencies
Compares two agents' runs step by step and names the step where one went
wrong. It guards Claude Code while it works, and lets a harness
evolve on a repository's own history: a change is kept only when paired runs
say it helped, and a weak win is run again. Every verdict is a rule over counts — a
model may narrate, never change a number.
Training · Post-Training · Eval
GPU Training Lab
~25 notebooks · live
~25 runnable notebooks covering the modern post-training stack end to end —
DPO, GRPO reasoning, RLHF, LoRA / QLoRA, full fine-tuning, and
distributed DeepSpeed training — plus LLM-as-Judge
and multi-trace agent evaluation, and multimodal (Qwen2.5-VL) runs. Everything runs on
free Colab / Kaggle T4 GPUs.
Agentic Training · Evaluation
Self-Learning LLM Training
Trainer → Judge → MetaJudge
A self-improving training loop where a hierarchy of agents —
Trainer → Evaluator → Judge → MetaJudge — drives,
evaluates, and critiques its own runs. The MetaJudge audits the Judge for bias and
escalates close calls to a human queue; Hyperband allocates compute
across an architecture search while a live dashboard streams round history, verdicts,
and traces. nanoGPT training with GRPO and speculative-decoding experiments.
Graph Intelligence · Agents
Bay Area Traffic — Live Network Intelligence
56 intersections · live
The Bay Area road network as a live, explorable graph — 56 intersections & the
five bridges as nodes, 90 highway segments as edges, with a time-of-day congestion model
updating in real time. Computes betweenness centrality to surface the critical
interchanges, clusters regions, narrates an automated traffic story, and answers
questions (“what if the Bay Bridge closes?”) — a free, in-browser
graph-intelligence engine, no API keys.
02
AI Systems Projects
Production-shaped LLM systems — retrieval, routing, agents, observability, and inference.
RAG
Production RAG
Production-grade RAG over private documents: hybrid BM25 + dense retrieval fused
via Reciprocal Rank Fusion, cross-encoder reranking, and answers with inline
citations traceable to source chunks. Ships prompt-injection detection, confidence-based
abstention, and a built-in evaluation suite + monitoring dashboard. FastAPI ·
ChromaDB · Sentence-Transformers.
Routing
LLM Router
Intelligent model routing that scores every model across task match, complexity
fit, cost, speed, and context to pick the optimal LLM per query — with
Balanced / Max-Quality / Max-Speed / Min-Cost modes across OpenAI and Anthropic models.
Runs entirely in the browser, no backend.
Agent Observability
OMNISCOPE
A multi-agent observability platform that captures the causal DAG of every
inter-agent decision (not flat logs), scores quality with a 6-judge LLM
panel, predicts failures on the live execution graph, and supports time-travel
debugging. Drop-in adapters for LangChain, CrewAI, AutoGen, OpenAI Agents, and Anthropic;
judges and embeddings run locally on Ollama.
Inference
Perf Explorer
An LLM-inference performance explorer: upload model perf sweeps and get a customer
go / no-go answer, an engineer sanity-check, and side-by-side comparison — parsed
and rendered live in the browser, no backend. React + TypeScript.
Multi-Agent
Agentic Post-Training Framework
A modular framework where specialized agents coordinate an LLM post-training pipeline
— technique selection → training → optimization → evaluation —
communicating over a structured message bus so the whole alignment
process is observable and debuggable. Apache-2.0, with a Colab + Pages demo.
Inference
SGLang vs vLLM Playground
A side-by-side LLM-serving benchmark: send the same prompt to SGLang and vLLM,
compare outputs, and measure time-to-first-token, total latency, and throughput
(tokens/sec) with batch benchmarks and interactive charts. FastAPI backend.
Multi-Agent
VoyageAI — Multi-Agent Planner
A supervisor-worker multi-agent system built on LangGraph, LangChain, and
Langfuse, where specialized agents (flights, hotels, activities, weather, budget,
itinerary) collaborate to produce a plan — with full tracing/observability of the
agent graph.
03
Research & Experiments
Hypothesis → experiment → measurement. Each project asks a concrete question and reports what the data actually says.
Eval Suite
ARES — Agentic RAG Evaluation Suite
F1 0.378 · +28.7%
55 configs swept
Searches the design space of a retrieval-augmented agent — retrieval depth,
BM25 / dense hybrid weighting, prompt style, query decomposition, self-reflection —
scoring each config on multi-hop QA (HotpotQA) and reporting the quality-vs-cost Pareto
frontier. Across 55 configurations, the winner reached F1 0.378
(+28.7% over baseline) at 0.12 s/question. Headline finding: chain-of-thought
prompting drove the entire gain — retrieval tuning barely moved F1, and
retrieval recall and answer-F1 were decoupled. Runs fully local on Apple Silicon (MPS).
Alignment
DPO from Scratch
Direct Preference Optimization on Qwen2.5-0.5B + Anthropic HH-RLHF
(8k preference pairs), β=0.1, LoRA — ~35 min on a free T4 — built to show
what the chosen / rejected log-probs actually do during training and what β trades
off. Includes a write-up: “I ran DPO. Here's what I saw.”
SWE-Bench
LocalSWEAgent
6/7 patches
$0 API cost
A lightweight SWE-bench agent asking whether a 3B model on a laptop can
fix real GitHub issues. Honest result: a Qwen2.5-3B agent produced valid patches for
6/7 reachable issues at $0 API cost — but resolved 0%,
consistently targeting the wrong root cause. Establishes a zero-cost baseline and pinpoints
exactly where small models break down.
GNNs
Graph Neural Networks
GAT 81.8%
NMI 4.5×
Trains GCN, GAT, and GraphSAGE on the Cora citation network and shows that
GNN-learned embeddings capture community structure 4.5× better than
raw features (cluster NMI 0.13 → 0.59); GAT reaches 81.8% test accuracy. Interactive
attention visualizations + Colab.
Training Orchestration
Multimodal Training Sweep
A parallel multimodal-LLM training-sweep orchestrator with watchdog crash / stall
recovery (halves the batch size and relaunches), SQLite-backed run + metric
tracking, an auto-generated comparison dashboard, and a Claude-written verdict on the best
variant — auto-published to GitHub Pages.
Distributed Training
Multi-GPU Training Viz
Trains the same nanoGPT four ways — single-GPU, DDP, FSDP, and DeepSpeed
ZeRO-2 — streaming per-step loss, throughput, memory, and grad-norm to JSONL
for side-by-side comparison, with a decision tree and documented multi-GPU gotchas.
Reproducible on free Colab / Kaggle T4s.
04
More Projects
Earlier interactive builds and data-visualization work — plus the full portfolio archive.
Interactive Viz · Live demo
LinkedIn Network Exploration
▶ animated reel
Synthetic / fake data
D3.js force graph
An interactive D3.js force-directed map of a professional network
(~499 people, 2,312 ties) with community detection, location clustering, and
betweenness-centrality highlighting, plus an unsupervised “surprise”
engine for bridge connections. All data shown is synthetic / fake —
no real LinkedIn connections are used.
The full archive of earlier projects, demos, and visualization work — research software, D3 / web experiments, and side builds collected in one place.
05
Open Source
Tools others can install and run — plus earlier research software licensed by UC / LBNL.
A pip-installable, drop-in observability tracer for AI agents: one import records the full run as a tree of spans — plans, decisions, tool calls, sub-agent invocations, memory ops, retries, and the underlying Anthropic / OpenAI calls. Structural capture, not just a timeline.
An observable, optimized RAG pipeline with a web UI, real span tracing and guardrails, a one-click Render deploy, and a no-API-key demo mode. Includes a LoRA Lab that fine-tunes a tiny adapter in pure NumPy (hand-written gradients) live on free-tier hardware.
A hierarchical visual exploration technique for fMRI data — the system behind an IEEE TCBB '16 paper. Licensed by the University of California through Lawrence Berkeley National Laboratory.
Interactive spatio-temporal cluster analysis of electrocorticography data — Best Paper at ACM-BCB '16, extended in BMC Bioinformatics '17. Licensed by the University of California through Lawrence Berkeley National Laboratory.
06
Technical Writing
34 essays, mostly interactive, organized as five short series — read any one alone, or follow a series top to bottom. Earlier long-form work lives on Medium.
Series 1 · Building agents that finish
Why long tasks fail and the machinery that fixes it — pacing, memory, forgetting, rollback, and the loop itself.
Agents
Your AI Agent Is a Marathoner, Not a Sprinter
Long-horizon agents fail like marathoners, not sprinters — a playbook on compounding error, context rot, pacing, checkpoints, context resets, and sub-agent relays, backed by a 20,000-trial simulation.
Agent Infra · Interactive
Agents Can Sprint. Memory Lets Them Run Marathons. · New & interactive
The sequel to the marathon post: the baton itself. Models sustain 30+ hour tasks but every context window still gets wiped — why agent memory and its deployment is the whole ballgame, via Anthropic’s long-running harness and Nous Research’s self-correcting Hermes — with a live "memory relay" simulation you can steer (failure rate, context size) and the design-review checklist.
Agent Memory · Interactive
Your Agent Has a Filing Cabinet. It Needs a Hippocampus. · New & interactive
Agents get one flat memory store; cognition runs four — working, episodic, semantic, procedural — wired by consolidation during sleep. The architecture mapped to agent infra (MemGPT, Generative Agents, Voyager assembled into one design), retrieval as ranking, forgetting as precision — and a live consolidation lab: 14 simulated days where the agent that sleeps ends ~50 points ahead of the one that hoards.
Agent Infra
We Gave Agents Memory but No Way to Forget · New & interactive
“Agent memory” is usually append-everything retrieval — and it makes agents worse over time. Why real memory needs forgetting, with a live in-browser simulation and a Colab notebook.
Agent Infra
We Gave Agents Tools but No Undo Button · New & interactive
Without rollback, long agents don’t just fail — they finish and corrupt state. The database wisdom that fixes it — checkpoints, idempotency, compensation — with a live simulation and a Colab notebook.
Agent Infra · Interactive
The 30-Hour Agent Is an Infrastructure Problem. · New & interactive
The loop as an operating system: context as RAM (compaction high-water marks, KV-cache discipline, spill-to-disk), tokens as the meter (hierarchical budgets, circuit breakers), watchdogs + Erlang-style supervision, and an eval pyramid for runs too long to rerun — with a live run console where toggling compaction, watchdog, or checkpoints decides whether a simulated 30-hour run survives.
Agent Reliability · Interactive
Long Tasks Don’t Fail. They Compound. · New & interactive
A 99%-reliable agent is a coin flip after 69 steps. Task success is per-step reliability raised to a power, and the horizon is one number:
ln(0.5)/ln(p). The 10× rule, why retries buy 2,500× less than the math promises once failures correlate, and a live horizon calculator that turns your step reliability into the longest task you can actually finish.
Context Management · Interactive
The Plan Is the First Thing You Forget. · New & interactive
Long-horizon agents don’t run out of context — they run out repeatedly and compress their way out, and compression takes the oldest thing first: the plan. Why compaction fidelity compounds (each doubling of task length squares the loss), why 90% fidelity retains just 43% over 800 steps, and a live lab running five context policies against one identical task.
Agent Operations · Interactive
You Don’t Deploy an Agent. You Operate a Fleet. · New & interactive
Every ops primitive you own — p99 latency, retries, canaries, circuit breakers — assumes work that takes milliseconds. Runs take hours. A live fleet view of 32 concurrent agents across one shift, a toggle that shows you exactly what your dashboard cannot see (78% reported, 50% real), and the five panels to build this week.
Post-Training × Memory · Interactive
Memory Is Post-Training With a Learning Rate of 1.0 · New & interactive
A memory write and a gradient step are the same operation at opposite ends of a learning-rate continuum. A derivable boundary for whether a fact belongs in context or in weights (
u×h>B, drawn as a phase diagram), why catastrophic forgetting and context compaction are the same bug, and the lab showing why self-training on your agent’s own successes gets more dangerous the better your model gets.
Agent Memory × Systems · Interactive
Your Context Window Is a Cache. Start Measuring It Like One. · New & interactive
Agent memory is a caching problem, and caching has sixty years of measurement behind it. AMAT, the three kinds of miss, and Belady’s optimal as an oracle you can actually compute from a logged run. Agent traces have inverted locality — the plan is the most needed and least recent thing — so LRU needs 69 slots to do what perfect eviction does in 20.
Series 2 · Knowing if they're any good
Evaluation and trust — from grading traces to catching gamed metrics to deciding when an agent may act alone.
Post-Training · RL · Interactive
Most of Your Rollouts Change Nothing. The Environment Decides How Many. · New · interactive
In GRPO a unanimous group has an advantage of exactly zero and still costs K rollouts. At a 99% pass rate that is 92.3% of your compute buying nothing — and the formula is symmetric, so too-hard and too-easy are the same failure. Shows environments decaying as the policy improves (89.5% useful groups down to 58.5% on a fixed prompt set) and prices the three ways out.
Agent Evaluation · Interactive · D3
Six Agents Finish the Same Task. The Trace Knows Who’s Better. · New & interactive
Six differently-scaffolded agents, one task, same harness — an answer-only judge calls it a six-way tie while the traces blow them apart. A trace-metric framework (recall@K, progress-AUC, loop rate, verification, pass^k), behavioral clustering with kNN drift alarms, and a live D3 fingerprint lab that runs the whole experiment in your browser.
Evaluation
You’re Grading Your AI on the Wrong Test · New
A benchmark win isn’t a model that works — a playbook on eval variance, contamination, biased LLM judges, and reliability@k, backed by a 20,000-trial simulation of how grading method beats raw model quality.
Self-Improving Systems · Essay
Catching Goodhart in the Act · New & interactive
I let a model improve itself against its own grader and watched the score climb while held-out truth quietly fell. Divergence-onset monitoring caught the gaming within 2–11 generations in 100% of gamed runs — with a live simulation and the "verifier half-life" playbook.
Agentic AI · Report
Fifteen Domains, One Wall: The Verification Gap · New
Read agentic AI across fifteen domains at once and the same wall appears in every one. Why the bottleneck was never generation — it’s verification — and where value migrates next: the “Trust Stack.”
Agent Autonomy · Interactive · D3
Autonomy Is a Dial, Not a Switch. · New & interactive
When should an agent ask, tell, or just act? An expected-loss framework (confidence × stakes × reversibility), a per-task-class trust ratchet, escalation mechanics that prevent rubber-stamping — and a live policy observatory: 400 streaming decisions, draggable thresholds, and a Pareto frontier showing exactly where your policy sits between interruptions and catastrophes.
Post-Training Evaluation · Interactive
You Didn’t Pick the Best Checkpoint. You Picked the Luckiest One. · New & interactive
A 200-item eval measures to ±3.2 points; checkpoints differ by one. Taking the max of noisy scores is selection, not measurement — in the live lab, best-of-twelve finds the genuinely best checkpoint 23% of the time and reports a score 4.8 points hot. Plus the pairing trick that buys a 4× power gain for zero extra compute.
Series 3 · Interfaces: tools, pictures, generated UI
The surfaces agents touch and produce — tool contracts, visualization as infrastructure, and answers that render.
Agent Infra · Interactive
Your Agent Isn’t Dumb. Its Tools Are. · New & interactive
Most “agent failures” are interface failures: a tool definition is a prompt the agent re-reads at every decision point. The seven sins of tool design (ambiguous names, kitchen-sink params, unbounded responses, dead-end errors…), a per-tool eval loop — and a live grader that scores any MCP / function-calling JSON on 8 dimensions as you type.
Visualization × Agents · Interactive
Agents Became Systems. Nobody Drew Them. · New & interactive
We debug distributed systems by scrolling JSONL. A five-layer framework for visualization across the agent lifecycle — trace waterfalls, behavior fingerprints, workflow flows, live architecture maps, deployment dashboards — grounded in Shneiderman / Tufte / Munzner, with a live D3 control room: plug the Planner, Memory, and Verifier in and out of a running agent system and watch the consequences flow.
Generative UI · Live Demo
Your Agent Answers in Paragraphs. It Should Answer in Interfaces. · New & live demo
Generative UI: agents that render the tool you needed instead of describing it. The specs-not-pixels architecture, UI components as tools, evals for interfaces — and a fully working playground in the post: type a request, watch intent → spec → validate → render light up, then use the generated charts, forms, trackers and timers. Edit the spec JSON, watch the UI rebuild.
Field Report · Interactive
The Last Click · New & live trace
An agent fixed a real open-source bug in forty minutes. Shipping it took five hours, two agent sessions, four permission walls — and exactly one human click. The complete trace of a real contribution, rendered as a live span waterfall next to its no-walls counterfactual, and the design lessons: prepared artifacts, legible denials, consent as the interface.
Voice Agents · Interactive
The Model Talks. Code Decides. · New & interactive
A phone scheduling agent for an invented family clinic. The model runs the conversation; four checks in code decide what reaches the calendar: who is calling, only times the calendar returned, a clear yes on a later turn, and asking when two patients fit. Replay five calls, including twins who share a birthday.
Series 4 · Strategy & economics
Where the durable value sits — the harness over the model, domain depth over generality, and the real cost of more agents.
Agent Strategy · Interactive
The Model Is a Guest. The Harness Is the House. · New & interactive
You’ll swap models five times and your product will still be itself — identity lives in the harness. A razor for what survives each swap (model-shape depreciates, world-shape compounds), the rehearsed swap protocol, the bitter-lesson counterargument taken seriously — and a live simulator: 36 months, six model generations, the moment the system detaches from its own model.
Agent Strategy · Interactive
The Next Million-Dollar Agent Is Boring and Domain-Specific. · New & interactive
General agents demo; domain agents invoice. The full playbook: collect & curate expert data into one corpus that compiles to three artifacts, climb the training ladder (scaffold → SFT → DPO → distill), answer by K verified paths with a judge, gate everything on a golden eval set, deploy on a trust ratchet — with a live multipath explorer showing what each extra path buys.
Multi-Agent · Report
More Agents Isn’t Better: The Coordination Tax · New
Two frontier labs reached opposite conclusions on multi-agent systems. The reconciliation — single strong agent by default; multi-agent only for verifiable, parallel breadth — plus the ~15× token tax and the MAST failure taxonomy.
AI Agents · Report
Your AI Agent Aced the Test. It Still Can’t Do the Job. · New
Capability soared while 95% of enterprise pilots returned nothing. Why reliability — not intelligence — is the wall for AI agents in 2026, and the operator’s playbook for crossing it.
Series 5 · ML foundations
The modeling layer underneath — retrieval systems and explaining what the ranker did.
Recommendation Systems · Chrome Extensions
Three Ways to Talk Back to a Recommender: RecoLens, SpotRecs and Netflix Lens · New
A YouTube re-ranker with a visible value model, a music recommender that borrows Last.fm signal, and a read-only X-ray of a Netflix page. How each one recommends, with screenshots and the numbers.
Serving · Deep Dive · Interactive
Ask Two Servers, Not One. The Tail Collapses. · New · interactive
Dispatch each request to a random replica and the busiest one runs 112 requests ahead of average, growing without bound as traffic rises. Probe two and take the shorter queue: the excess pins at 1.9, flat across three orders of magnitude. Worth 18× at p99 under load — and the second extra probe buys only 2.3× more, which is why you stop at two.
Retrieval · Deep Dive · Interactive
Your Chunker Is Deleting Facts. The Overlap You Need Is Exact. · New · interactive
A 256-token fact in 512-token chunks with no overlap is retrievable exactly half the time — not ranked badly, absent. Derives the one-line formula, shows the overlap you need is your longest fact and not a percentage, prices the guarantee, and explains why your retrieval eval structurally cannot see the failure. Live chunker you can drag.
Retrieval · Deep Dive · Interactive
A Fifth of Your Corpus Is Unreachable. It Isn’t the Dimensions. · New · interactive
Drop the L2 normalization and 18.6% of a 500-vector corpus is never returned to any query, while one vector takes 191 of 5,000 result slots. Normalize and it is 0.0% at every dimension. The usual explanation — the curse of dimensionality — turns out not to fit the measurement: the villain is a length gradient, and the lab rebuilds the whole index in your browser so you can check.
Inference · Deep Dive · Two Labs
Your Model Guesses Ahead. The Ceiling Is Exact. · New · interactive
Speculative decoding has a closed form, and a hard edge nobody puts on the slide: a step settles at most 1/(1−a) tokens, so an acceptance rate of 0.8 caps you at 5× with a free drafter and an infinite draft. Derives the ceiling, proves guessing pays iff a > c, and shows the part benchmarks hide — the median gets faster while the p99 runs 67% past it on the short bursts agents actually emit.
ML System Design · RecSys · Interactive
Designing a Recommender for 100 Million Users · New & interactive
The full ML system design interview, worked end to end: a video home feed at 28K QPS. Objective and labels, a live capacity calculator, the three-time-scale architecture, two-tower retrieval, multi-task ranking, re-ranking, cold start, training and serving at scale, evaluation, and the follow-ups that separate senior from staff answers.
Retrieval / RecSys
Two Towers, One Index: How Retrieval Models & ANN Search Are Co-Designed · New · interactive
A source-grounded deep dive with a drag-to-explore demo: the two-tower model and approximate nearest neighbor search are one co-designed system, not two. From DSSM and the logQ correction to HNSW, IVF-PQ and ColBERT — and how the exact same machine powers recommendation feeds. Assembled by a fact-checked multi-agent research pass.
Systems · Two Interactive Labs
Your GPU Is Not Computing. It Is Waiting. · New & interactive
Generating one token from a 70B model on an H100 uses 0.34% of the chip. The memory wall derived from first principles — roofline and arithmetic intensity, the KV-cache capacity wall, FlashAttention’s online softmax and I/O complexity, and every optimization (batching, quantization, speculation, GQA, paging, tensor parallelism) as one move on one chart. Two live labs.
Explainability
Why Did You Rank That? Explainability for LLM-Powered Retrieve-and-Rank · New
A method-by-method field guide to explaining the four-stage ranking funnel — SPLADE/ColBERT structural readouts, RankingSHAP, activation patching, faithful logit signals, counterfactual stage ablation — and the one rule underneath them all: plausible is not faithful. Fact-checked multi-agent research pass.
Earlier writing · Medium
Designing deep learning models is hypothesis-driven; interpretability is key to trustworthy models — the Achilles' heel of deep neural networks.
An attempt to clearly explain the simplest ML algorithm in Python — predicting a linear relationship between inputs X and an output Y.
Neural networks are now ubiquitous — convolutional, recurrent and beyond — with manifold applications across medicine, transportation, and visualization.
The importance of visual analytics in machine learning, as ML methods play an increasingly influential role in the world.
Transportation, brain, and social networks all rely on machinery from graph theory and data visualization.
07
AI Infrastructure & Experience
Where the models meet production — experience across industry research and the infrastructure that scales AI systems.
Experience
-
Building and shipping LLM-powered recommendation and agentic-AI systems in production. Also DeepInsight — a real-time ML analytics engine for network understanding (C++, Python, Kubernetes, Kafka, GoLang, TensorFlow, Apache Flink, ML anomaly detection).
-
Research Engineer — Samba TVCo-creator of Sambavision — applied ML/CV research shipped into product.
-
Research Intern — Adobe ResearchInterpretable deep learning — DeepCompare, for comparing and debugging deep models (patent + IEEE CG&A).
-
Graduate Fellow — Lawrence Berkeley National LabComputational Research Division — large-scale scientific data + ML.
Education
-
PhD in Computer Science — UC Davis
-
Research Associate — UC BerkeleyIn conjunction with Lawrence Berkeley National Laboratory.
Infrastructure & Scale
The systems work behind the models. At Intel / Intuit I help build DeepInsight, a real-time ML analytics engine — streaming pipelines on Kafka and Apache Flink, services in C++ / GoLang / Python on Kubernetes, with ML anomaly detection. The same instinct runs through my open-source work: distributed training (DeepSpeed / FSDP / DDP), inference serving, and agent observability — infrastructure in service of shipping and scaling AI systems.
20+
Open-source AI projects
8
Peer-reviewed papers
3
Reviewer: NeurIPS, ICML, ICLR
150M+
Users in production
08
Publications
Peer-reviewed research — modelling data through mathematical models and visualization, with a Best Paper award and a patent.
Interactive DeepCompare Model Analysis: Comparing Deep Learning Models
IEEE Computer Graphics and Applications
PhD Dissertation: Visual Analysis Methods for Static and Dynamic Networks
University of California, Davis & Lawrence Berkeley National Laboratory
Brain Modulyzer: Interactive Visual Analysis of Functional Brain Connectivity
IEEE Transactions on Computational Biology '16
Hierarchical Spatio-temporal Visual Analysis of Cluster Evolution in Electrocorticography DataBest Paper
ACM-BCB '16 — 7th ACM International Conference on Bioinformatics, Computational Biology
09
Skills
Organized for AI research engineering. Highlighted skills are where I do my deepest work.
AI & Machine Learning
Research & Evaluation
Systems & Infrastructure
Programming
Cloud & GPU
Cloud & GPU in service of training and serving models.
Distributed Systems
Used to scale data and AI workloads — the plumbing behind production ML.
10
Contact
The fastest ways to reach me and see the work.
Get in touch
I'm always happy to talk about LLM post-training, agent evaluation, RAG, and the infrastructure that scales AI systems. Email is best — or browse the code on GitHub.
Open to ML & Research Engineer opportunities