Simran Arora

Simran Arora researches efficient AI models and the systems that run them. Her collaborative work connects what a language model can remember with the memory, computation, and communication its implementation requires. Projects including Based, ThunderKittens, Cartridges, and ParallelKernelBench examine these costs alongside the capabilities an application needs.

Training and early work on personalization

Arora earned her undergraduate degree at the University of Pennsylvania in 2019 and her computer-science doctorate at Stanford in 2025, working with Christopher Ré in the Hazy Research Lab. She also co-created and taught Stanford’s Systems for Machine Learning course in fall 2023. At her 2026 AI Engineer talk, she described herself as a principal scientist leading Together AI’s Frontier Performance research team and an incoming professor at Caltech.

Her earlier research explored how foundation models could support private, personalized applications. In writing with Christopher Ré on privacy and personalization, she examined approaches to using personal information without requiring large private training datasets or sacrificing privacy guarantees. Collaborative research on retrieval across public and private information addressed the different data distributions those systems must handle. Knowledge access, application quality, and cost were connected design problems.

Recall, efficient architectures, and reusable context

That concern with access to information also shaped her work on efficient language models. Arora, Sabri Eyuboglu, Michael Zhang, and their collaborators developed Zoology to investigate why some alternatives to Transformers struggled to recall information from their prompts. Broad metrics could conceal failures on predictions requiring an earlier association. Simple synthetic tests initially missed the weakness; tests requiring multiple lookups exposed how the resources needed for recall changed with sequence length. A cheaper layer could require a wider model to recover the missing capability, making task-level resource requirements more informative than per-layer complexity alone.

• Based: recurrent memory: These findings helped motivate Based, a recurrent language-model architecture combining local mixing with linear attention. Local operations handle nearby relationships, while linear attention carries information over longer distances through a fixed-size recurrent state. The architecture gives researchers ways to trade memory and throughput against recall. In her one-year retrospective, Arora emphasized careful characterization of those tradeoffs: broad claims about efficient architectures can obscure the tasks on which they still struggle.
• Cartridges: reusable context: With Cartridges, Arora and her collaborators approached repeated context as reusable memory. They train a compact key-value cache offline for a corpus such as a codebase or document collection. Their self-study method generates synthetic conversations about the material and distills context-conditioned behavior into the cache. Multiple requests can then reuse the cartridge, spreading preparation costs across queries. Simply training on next-token prediction from the corpus proved insufficient; the training method mattered to whether the stored context was useful.

From GPU kernels to multi-GPU communication

Arora’s GPU programming work addresses whether such efficiency gains translate into fast execution. She co-authored ThunderKittens, which organizes kernel programming around matrix tiles and templates for overlapping work. Its abstractions follow the GPU execution hierarchy, from operations within a warp to coordination across thread blocks, making kernels easier to express while retaining control over hardware resources. She also co-authored HipKittens, which develops tile-based abstractions for high-performance AMD GPU kernels.

Her multi-GPU work extends this approach to communication. In her 2026 talk, Arora argued that improvements in single-GPU execution had made communication an increasingly important bottleneck in distributed training and inference. Bulk-transfer libraries offer convenient baselines, but fine-grained communication and fused operations can require custom kernels. She and her collaborators developed ParallelKittens by first studying the underlying tradeoffs manually, then expressing them through a small set of primitives and programming patterns.

Those tradeoffs involve both how data moves and how work is scheduled. CPU-initiated copy engines suit large transfers and leave GPU compute resources available. Device-initiated tensor memory accelerator transfers can achieve high bandwidth with smaller messages while consuming few registers and processors, making them useful for fine-grained overlap. Register-level transfer instructions provide access to in-network reductions that the tensor memory accelerator cannot effectively exploit. Scheduling adds another choice: computation and communication can use specialized warps within the same streaming multiprocessor when their data requirements align, or separate multiprocessors when they need different resources. Arora illustrated the distinction with matrix multiplication followed by reduce-scatter, where the first arrangement worked well, and matrix multiplication followed by all-reduce, where the second could exploit in-network reductions. ParallelKittens keeps buffering and synchronization choices available to the programmer alongside these mechanisms.

Testing language models on multi-GPU kernels

Arora co-authored ParallelKernelBench to test whether language models could reason through these choices and generate useful multi-GPU kernels. Its 87 problems cover patterns from real AI workloads. Each task supplies an unoptimized PyTorch distributed reference and a hardware topology; the model must produce a CUDA implementation. The evaluation separates correctness from performance, checking both whether a kernel works and whether it outperforms the reference.

In the results she presented, the best tested model in the zero-shot setting solved 28 of 87 problems, with 22 solutions faster than the reference. Additional samples raised correctness to 36 solutions, while the share of problems with faster solutions plateaued at roughly 31%. An agent harness with local shell access improved Gemini 3 Pro from 24 to 35 correct solutions, with 26 faster than the reference, but performance again plateaued as more time was allowed. Compilation and error correction were easier to improve than reasoning about collective ordering, data partitioning, scheduling, and transfer mechanisms. Successful kernels were concentrated in familiar patterns, which Arora treated as a warning against assuming the models had learned the underlying tradeoffs.

The benchmark’s practical aim is to produce useful kernels for workloads that have received less manual optimization. Arora highlighted generated examples involving NeMo vocabulary-parallel filtering, Hyena context parallelism, and intersection-over-union suppression in SAM 3 video segmentation. Her work makes the remaining challenge concrete: execution feedback can help a model produce a working program, while fast multi-GPU execution still requires choosing communication and scheduling strategies that fit the hardware and workload.