Research interests
- Inference timing and queueing: Credit-to-completion latency, queueing delay, and where benchmark clocks start. Read: Where LLM inference benchmarks hide queueing delay
- Vector retrieval and compression: Quantization, representation error, and retrieval quality. Read: Three-bit vectors, three different retrieval outcomes
- Search and data structures: Query routing, probabilistic membership filters, and the work hidden behind a lookup. Read: Switchyard routing · Read: Bloom-filter allocation
- Training systems and memory: Tensor communication boundaries, optimizer state, and the memory budget for training. Read: Tensor parallelism · Read: ZeRO memory
- Attention and inference memory: Online softmax, cache growth, and the information retained for decoding. Read: Online softmax · Read: KV-cache memory
- Reinforcement learning and agents: What clipped objectives constrain and how repeated task success should be measured. Read: PPO clipping · Read: Agent reliability
- Networking and propagation: Bandwidth-delay product, queueing, and the geometry of satellite routes. Read: Bandwidth-delay product · Read: Satellite routing
- Control and model uncertainty: Safety-filter assumptions and the difference between disagreement and correctness. Read: Control barrier filters · Read: Model uncertainty
- Computer vision geometry: Camera calibration, depth hypotheses, and projection into a bird’s-eye grid. Read: Bird’s-eye view geometry
- GPU memory access: Global-memory coalescing, shared-memory layout, and transpose indexing. Read: CUDA transpose
- Distributed databases: Bloom-filter allocation and what quorum arithmetic leaves out. Read: Bloom filters · Read: Quorum protocols
Selected writing
- · Where LLM inference benchmarks hide queueing delay
A FIFO queue analysis separates dispatch time from time spent waiting before dispatch.
- · Three-bit vectors, three different retrieval outcomes
A reconstruction study tests how three-bit vector quantization changes nearest-neighbor recall across synthetic geometries.
- · 100 identical loss logs, 100 different model states
A CPU replay study compares float32 reduction order and checkpoint-state restoration.
- · How should AI jobs share different GPUs?
A local allocation experiment studies heterogeneous GPU scheduling policies and weighted objectives.
- · Every Query Pays the Same Price, and That Is the Bug
An offline ESCI evaluation separates relevance from assumed route costs; a learned policy improves utility on a separate 461-query holdout.
- · The KV Cache Is the Memory Wall
A corrected KV-cache size model and CPU-reference synthetic traces compare attention-output fidelity across cache-retention policies.
- · How to Contribute to Open Source at Big Tech
One CUDA-Q change merged; GTSAM and Warp fixes did not. The update explains the API and maintenance constraints behind each outcome.
- · How I Got Into the OpenAI Student Collective
A first-person account of the application and the campus program role.
- · How I Got Into the MLH Fellowship
A first-person account of the Open Source Track application, including IBM aiu-trace-analyzer PR #98.
- · When a Barrier Filter’s Assumptions Break
A scalar control barrier filter makes its assumptions visible: continuous feedback, sampled commands, model bias, and actuator feasibility.
- · CUDA Transpose: Coalescing and Bank Padding
Rectangular indexing and a simple bank-address model separate two optimizations: contiguous global access and padded shared-memory layout.
- · Online Softmax Without the Attention Matrix
Running maxima and rescaled sums recover exact attention arithmetic without retaining every score. A small CPU example makes the invariant explicit.
- · The Bandwidth–Delay Product Knee
A single-bottleneck model separates the inflight data that sustains throughput from the extra data that adds queueing delay.
- · From Camera Pixels to a Bird’s-Eye Grid
Depth hypotheses place a pixel along several points on a camera ray. Their weighted projection exposes the effects of calibration and grid resolution.
- · Tensor Parallelism’s Communication Boundary
A paired matrix partition shows where tensor parallelism needs communication, and why the nonlinearity determines that boundary.
- · What PPO Clipping Actually Limits
The clipped surrogate removes incentives in one direction at a time. It does not enforce a hard probability-ratio or KL bound.
- · When a Longer Space Route Is Faster
An explicit satellite chain shows when faster propagation compensates for the climb to orbit, with Earth-clearance checks for every space link.
- · Reliability Beyond One Successful Run
All-k success and best-of-k success answer different questions. Exact estimators and synthetic trials show why task heterogeneity matters.
- · When Dynamics Models Agree and Still Fail
Within-model noise and between-model disagreement describe different uncertainty. An exact counterexample shows how shared bias escapes the second.
- · ZeRO’s Memory Budget, Byte by Byte
Parameters, gradients, and optimizer state account for different parts of training memory. ZeRO changes who stores each part.
- · Giving Small Runs Better Bloom Filters
A fixed memory budget produced 47.21% fewer false-positive probes when the smallest runs received more bits per key.
- · What Quorum Arithmetic Leaves Out
Two replica traces show why membership and read write-back matter alongside R + W > N.
Research notes
Technical notes on systems, agents, and public measurements. Each article links to its sources, data, figure, and runnable notebook where included.
Training, serving, and networking
- · Why can a bigger network buffer make an application slower?
Compare a tall, short delay burst with a smaller persistent delay and inspect the timer that distinguishes them.
- · When is it worth separating prompt processing from token generation?
A latency-budget example explains prefill/decode separation, KV transfer overhead, and the handoff token gap that steady-state averages can hide.
- · Why would a controller be rewarded for staying unpredictable?
Solve a three-action decision exactly to see what an entropy bonus buys, what it costs, and why reward units matter.
- · What does a scheduler lose when it ignores job dependencies?
Four tasks can occupy two workers for two, three, or four ticks depending only on their dependency graph.
- · Is a safety constraint the same as a large negative reward?
A one-decision constrained problem shows why penalties need calibration and why an expectation constraint is not a guarantee for every run.
- · Why does an agent learn from old experiences?
Inspect the order of a tiny replay buffer to understand data correlation, off-policy reuse, and the limits of shuffling without new experience.
- · Why does one slow server matter more as a service grows?
Derive the latency of the slowest worker and show why a correlation assumption must be stated, not silently folded into a p99 chart.
- · When does GPU time-slicing speed up useful feedback?
A deterministic round-robin simulation shows how training time-slicing trades first-feedback latency against switching overhead.
- · How do microbatches change pipeline idle time?
A four-stage schedule calculation explains GPipe microbatch bubbles, stage imbalance, and why more microbatches do not remove every bottleneck.
- · Why does an imitation learner struggle after its first mistake?
Use a tiny disturbed path-following world to see how expert labels on learner-visited states differ from simply collecting more perfect demonstrations.
- · How can congestion feedback protect short requests from large transfers?
Calculate DCTCP’s smoothed congestion estimate and isolate how it changes a window reduction.
- · Why should an LLM server reschedule after every token?
A three-request timeline isolates how iteration-level scheduling admits new work into a batch before its longest request completes.
- · Can a scheduler learn to pack two resources at once?
Schedule three jobs on two resources and verify exactly how a per-timestep reward becomes total job slowdown.
- · How much KV-cache space do variable-length requests waste?
A small allocator calculation quantifies KV-cache reservation waste, page-size tradeoffs, and the benefit of sharing full prefix blocks.
- · Why can more training examples per second mean slower learning?
A small optimization example separates examples per second from time to a learning target, explaining the goodput question behind Pollux.
- · When does a reward bonus change the task an agent learns?
A two-path MDP shows how a tempting reward bonus changes the preferred action, while correctly discounted potential shaping preserves it.
- · Will a learned streaming policy handle a network it has never seen?
A chunk-level buffer calculation shows why equal-looking bandwidth summaries can produce very different stalls and quality tradeoffs.
Agents, tools, and evaluation
- · When benchmark averages reverse an agent ranking
An 83% overall score can lose to 80% under equal family weighting. The crossover can be calculated rather than argued over.
- · The gap between a fresh screenshot and a safe tap
Re-observation narrows the stale-state window. Only an executor-enforced revision check closes it in this timing model.
- · A fixed seed is not a reset contract
A cached choice survives a partial reset, changes every starting fingerprint, and breaks half the repeated tasks.
- · What a search budget cannot fix after early pruning
A nine-leaf tree separates exploration, pruning, and work actually used. More budget cannot recover a branch already discarded.
- · Structured edit errors make recovery programmable
A transactional editor can preserve source state and expose a repairable error. Syntax acceptance still says nothing about intended behavior.
- · Why parallel sums disagree: tracing FP32 reduction order
Two correct addition orders return zero and one for inputs whose exact sum is two. Enumerating every input order reveals the numerical contract.
- · Why normalized clicks miss fixed-margin controls
A viewport-relative point and a right-anchored control obey different transformations. Target width decides when that difference becomes a miss.
- · The payoff tables a monotonic QMIX mixer cannot represent
Exact two-by-two tests separate additive values, nonlinear monotonic synergy, and a ranking reversal that no fixed utility order can express.
- · When should a ReAct-style agent refresh its observations?
Refreshing evidence turns three invalid takes into two completions and one honest abstention. It still cannot make a later mutation atomic.
- · Memory needs a scope: a rule-change test inspired by Reflexion
A 30-episode trace shows why the conditions attached to a failure note matter more than the size of the notebook.
- · A patch needs two test partitions
Fixing the reported issue and preserving ordinary behavior are separate obligations. Fifteen repairs make the difference visible.
- · A tool response cannot grant execution authority
A dispatch boundary checks the proposal against an independent grant. External wording remains data, even when it sounds imperative.
- · Selective tool calls: finding the cost threshold
A carry-detection fixture makes the error–latency trade-off explicit, including the point at which a perfect calculator stops being worthwhile.
- · What text-only observations erase in visual web tasks
Four identical labels hide four different colors. A contact sheet exposes exactly what the observation representation keeps and loses.
- · WebArena’s evaluation lesson: check the final state
A cart message, a URL, and a persisted-state predicate disagree on the same 20 terminal states. The disagreement is the test.
- · Retrieval relevance is not constraint satisfaction
A higher-ranked product can violate a hard requirement. Validation helps only if retrieval includes a feasible alternative.
Public datasets and benchmark analysis
- · The cost of asking a learned index for a key
A nine-row reanalysis of Apple’s AMIPS timing table separates a promising component ratio from the end-to-end claim it cannot yet support.
- · The denominator inside a geospatial benchmark
A metadata census of Google’s GeoKTools and GeoExpertQueries shows why coverage, task mixture and scoring rules must accompany a single aggregate score.
- · The Server/Offline ratio is workload-specific
A matched analysis of 152 MLPerf Inference v6.1 Server/Offline pairs shows that the ratio varies by workload; one separate released result exceeds 100%.
- · Audit the evaluation before trusting the score
OpenAI’s public monitorability release contains a useful contract for prompts and labels. Its mock runner is a different kind of evidence from a model evaluation.
Research and engineering experience
Research Assistant
LLM optimization with KV-cache optimization. KV-cache writeup →
Network & Security Intern
Network configuration and endpoint security across client IT infrastructure, including hardening, monitoring, and support.
Campus Lead
Developing Rutgers programming around practical ChatGPT and Codex use through faculty partnerships, student-organization outreach, and hands-on learning sessions. Program story →
Software Engineering Fellow
Contributing production code through implementation, testing, code review, and remote collaboration with engineers and mentors. Fellowship story →
About
I’m a Computer Science and Data Science undergraduate at Rutgers University. My work focuses on AI systems, inference, retrieval, and evaluation.
Field notes
- · Portfolio pass on structure and pacing
Tightened the site around the systems-first story. The main goal was to make the page feel less like a list of facts and more like a sequence: who I am, what I build, how I think, and where the work is headed.
- · CachePilot notes
Still thinking about inference from the hardware side first. KV cache pressure is where a lot of the real bottleneck shows up, so the work keeps circling back to memory locality, paging strategy, and what actually moves the throughput line.
- · Why systems work keeps winning my attention
The interesting part is usually not the headline model idea. It is the constraint underneath it: bandwidth, latency, scheduling, power, coordination, and the set of tradeoffs that decide whether something survives contact with reality.
Reading
Build a Large Language Model (From Scratch)Sebastian Raschka
Atomic HabitsJames Clear
Also reading: Designing Data-Intensive Applications.