1. Building Effective Agents (Anthropic, 2024) — Simple agent and workflow design patterns.
2. Tree of Thoughts: Deliberate Problem Solving with Large Language Models (2023) — Search and planning beyond a single reasoning trace.
3. Reflexion: Language Agents with Verbal Reinforcement Learning (2023) — Feedback and memory across attempts.
4. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning (2025) — Reasoning-model background; focus on the method overview.
5. Kimi K3: Open Frontier Intelligence (July 2026 technical report) — Agentic capabilities and supporting infrastructure; Section 5.3.2 covers AgentENV.
6. Introducing System One Models & Jev (TypeSafe AI announcement, September 15, 2026) — Typed probabilistic decisions as an alternative interface for agent components.

1. Why do prefill and decode have different performance bottlenecks? How can batch size change whether execution is compute-bound or memory-bound?
2. Design a small experiment to compare two edge machines. Which model settings, input/output lengths, and latency/throughput metrics would you control or report?
3. Why does request-level batching waste capacity when requests finish at different times? How does Orca’s iteration-level scheduling address this, and what tradeoffs remain?

1. LLM Inference Performance Engineering: Best Practices (Databricks / MosaicML, 2023) — Inference metrics, batching, and performance tradeoffs.
2. Attention Is All You Need (2017) — Transformer architecture refresher.
3. All About Transformer Inference (How To Scale Your Model) — Analytical treatment of inference bottlenecks.
4. Fast Inference from Transformers via Speculative Decoding (ICML ’23) — An extension for reducing autoregressive decoding latency.
5. A Survey of LLM Inference Systems (James Pan and Guoliang Li, 2025) — Optional comprehensive reference for the inference-systems portion of the course.

1. Identify two sources of KV-cache memory waste that PagedAttention addresses. What are the tradeoffs of larger versus smaller allocation blocks?
2. For a tool-calling task on one model instance, when would you preserve, discard/recompute, or offload its KV state during a pause? How could chunked prefill change the cost of resuming, and when would it provide no benefit?

1. InferCept: Efficient Intercept Support for Augmented Large Language Model Inference (ICML ’24) — Preserve, recompute, and offload KV state across tool calls; chunked recomputation and overlap.
2. Taming Throughput-Latency Tradeoff in LLM Inference with Sarathi-Serve (OSDI ’24) — Chunked prefills and mixed prefill/decode batches.
3. SGLang: Efficient Execution of Structured Language Model Programs (2024) — RadixAttention and structured model programs.
4. FastServe: Iteration-Level Preemptive Scheduling for Large Language Model Inference (NSDI ’26) — Preemption and head-of-line blocking.

1. Choose one ThunderKittens abstraction and explain which hardware constraint it addresses. How do tile layout, data movement, and asynchronous execution affect a kernel’s performance?
2. Trace a matrix multiplication from a model framework to execution on a GPU. Which decisions belong to the graph compiler, kernel implementation, and runtime, and why can a fast isolated kernel fail to improve end-to-end inference?

GPU programming and software stack

1. DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence — Sections 3.1–3.3: fused expert execution, communication/computation overlap, TileLang, and deterministic kernels.
2. FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness (NeurIPS ’22) — Tiling and memory-traffic reduction for exact attention on GPUs.
3. Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations (MAPL ’19) — Tiled programming, compiler IR, and optimization; the original language differs from today’s Python API.
4. PyTorch 2: Faster Machine Learning Through Dynamic Python Bytecode Transformation and Graph Compilation (ASPLOS ’24) — TorchDynamo, AOTAutograd, and TorchInductor: from framework programs to generated kernels.
5. Triton Kernel Compilation Stages (PyTorch technical article) — A concrete walkthrough of compiler lowering to GPU code.
6. How to Think About GPUs (How To Scale Your Model) — Optional hardware and memory-hierarchy refresher.
7. VDCores: Resource Decoupled Programming and Execution for Asynchronous GPU (2026 preprint) — Decoupled memory/compute abstractions and dependency-driven GPU execution.

AI-based kernel generation and megakernels

1. KernelBench: Can LLMs Write Efficient GPU Kernels? (ICML ’25) — Evaluating generated kernels for both correctness and speed.
2. CUDA-L1: Improving CUDA Optimization via Contrastive Reinforcement Learning (ICLR ’26) — Learning to optimize CUDA kernels using execution feedback.
3. Mirage: A Multi-Level Superoptimizer for Tensor Programs (OSDI ’25) — Search-based kernel optimization across several abstraction levels.
4. MPK: A Compiler and Runtime for Mega-Kernelizing Tensor Programs (OSDI ’26) — Mirage Persistent Kernel: cross-operator scheduling and an in-kernel runtime.
5. Look Ma, No Bubbles! Designing a Low-Latency Megakernel for Llama-1B (Stanford Hazy Research, 2025; technical blog with code) — ThunderKittens megakernel case study: persistent execution and reducing pipeline bubbles.

1. Why does PowerInfer place frequently activated neurons on the GPU and compute other neurons on the CPU? Relate the design to memory capacity, activation locality, and transfer costs.
2. Which profiling results would you need before applying this design to an integrated GPU with shared memory? Design a comparison that separates sparsity benefits, model quality, and execution-system improvements.

1. Get Started with MLX for Apple Silicon — Apple WWDC25 presentation: unified memory, lazy execution, and CPU/GPU programming.
2. MLX LM — Open-source local generation and fine-tuning on Apple Silicon; an optional comparison with the course’s AMD/Intel machines.
3. PowerInfer-2: Fast Large Language Model Inference on a Smartphone (2024 preprint) — CPU–NPU execution, neuron caching, and flash I/O for memory-constrained inference.
4. AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration (MLSys ’24) — Focus on Section 4 (TinyChat): fused dequantization, weight packing, and runtime performance.
5. LLM in a flash: Efficient Large Language Model Inference with Limited Memory (ACL ’24) — Flash-resident weights, I/O reduction, and memory layout.
6. SolidAttention: Low-Latency SSD-based Serving on Memory-Constrained PCs (FAST ’26) — A recent storage/memory co-design for local inference.
7. llama.cpp: LLM Inference in C/C++ (Runtime documentation) — Practical local inference and benchmarking reference.

TPU papers and edge NPU references

1. In-Datacenter Performance Analysis of a Tensor Processing Unit (ISCA ’17) — First-generation inference TPU.
2. A Domain-Specific Supercomputer for Training Deep Neural Networks (Communications of the ACM, 2020) — The move from inference accelerators to TPU training systems.
3. Ten Lessons from Three Generations Shaped Google’s TPUv4i (ISCA ’21) — Evolution of inference accelerator design.
4. TPU v4: An Optically Reconfigurable Supercomputer for Machine Learning with Hardware Support for Embeddings (ISCA ’23) — Accelerator, interconnect, and embedding support.
5. Google’s Training Supercomputers from TPU v2 to Ironwood: Architectural Stability, Scale, Resilience, Power Efficiency, and Sustainability Across Five Generations (2026) — A recent retrospective across TPU generations.
6. AMD XDNA Architecture (AMD architecture overview) — Edge NPU tiles and local data movement.
7. OpenVINO GenAI on NPU (OpenVINO 2026 documentation) — Edge NPU compilation and deployment constraints.

1. Which measured hardware differences motivate HeteroInfer’s execution strategy? Which conclusions would need to be remeasured on the AMD and Intel course machines?
2. Contrast placing stages within one SoC with routing complete requests between two machines. How would queueing, shared-memory contention, network transfer, and model residency enter each decision?

1. Rethinking DVFS for Mobile LLMs: Unified Energy-Aware Scheduling with CORE (MLSys ’26) — Coordinating CPU, GPU, and memory frequencies for latency and energy.
2. Act Before It’s Too Late: Power-Efficient LLM Inference on Mobile Device (MobiSys ’26; TurboInfer) — GPU stall-aware frequency control for mobile inference.
3. Agent.xpu: Efficient Scheduling of Agentic LLM Workloads on Heterogeneous SoC (2025 preprint; revised 2026) — Foreground/background agent flows and heterogeneous scheduling.
4. PowerInfer-2: Fast Large Language Model Inference on a Smartphone (2024 preprint) — Another approach to heterogeneous on-device inference.
5. Inference in the Shadows: Taming Memory Bandwidth Contention in Mobile LLM Inference with Sereno (OSDI ’26) — Inference interference with foreground applications.
6. When NPUs Are Not Always Faster: A Stage-Level Analysis of Mobile LLM Inference (2026 preprint) — Stage-level profiling, overhead, and backend fallback.
7. Preble: Efficient Distributed Prompt Scheduling for LLM Serving (ICLR ’25) — Prefix locality versus load balancing.

1. What is the memory hierarchy in MemGPT, and how are transfers between its levels initiated? Which costs are hidden by the analogy to virtual memory?
2. For an agent that invokes tools repeatedly, distinguish conversation history, persistent application state, and the model’s KV cache. Which can be discarded, reconstructed, or shared safely?

1. Model Context Protocol: Architecture (MCP specification, 2026-07-28) — Current protocol architecture rather than the original announcement.
2. Toolformer: Language Models Can Teach Themselves to Use Tools (2023) — Learning when and how to call tools.
3. An LLM Compiler for Parallel Function Calling (ICML ’24) — Dependencies and parallel tool execution.
4. A-MEM: Agentic Memory for LLM Agents (2025) — Structured persistent memory.
5. Recursive Language Models (2025 preprint; revised 2026) — Programmatic access to context and recursive processing.

1. Why does TClone separate low-latency workspace forking from durable checkpointing? What state must be captured or shared to fork a live GUI environment?
2. How should a runtime select and commit one speculative branch while isolating the others? Discuss conflicts with concurrent human edits and an external action that filesystem or process rollback cannot undo.

1. Kimi K3: Open Frontier Intelligence — Section 5.3.2: AgentENV isolation, pause/resume, forks, checkpoints, and image distribution.
2. NVIDIA OpenShell — Sandbox architecture: enforcement outside the untrusted agent, filesystem/syscall restrictions, and network mediation.
3. OpenSandbox — Alibaba-origin open-source project: lifecycle/execution APIs and pluggable sandbox backends; see the architecture documentation.
4. Meta: How We Built Safety Into Muse — Production case study of agent isolation and authorization.
5. Firecracker: Lightweight Virtualization for Serverless Applications (NSDI ’20) — Isolation and startup-cost foundations.
6. Crab: A Semantics-Aware Checkpoint/Restore Runtime for Agent Sandboxes (2026 preprint) — Recovering OS-visible effects, not only chat history.
7. DeltaBox: Scaling Stateful AI Agents with Millisecond-Level Sandbox Checkpoint/Rollback (2026 preprint) — Efficient sandbox state management.
8. AgentENV: A Distributed Platform for Running Agent Environments at Scale (GitHub repository) — Firecracker sandboxes, snapshots, forks, and distributed environment management.

1. Choose two attacks from the SoK that target different parts of an agent system. For each, identify the attacker’s control, the trust boundary crossed, and a defense with its key assumptions.
2. How would you evaluate a defense without rewarding an agent that simply cannot perform the legitimate task? Explain how to measure both security and utility, including when context truncation removes an attack.

1. OpenShell: Sandbox Architecture — Enforcement boundaries and policy placement; consider what a permitted destination can still receive.
2. OpenSandbox: Architecture — Distinguish execution APIs, isolation backends, and network policy from defenses against prompt injection.
3. AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents (NeurIPS ’24) — Paired task utility and attack evaluation.
4. Defeating Prompt Injections by Design (CaMeL, 2025 preprint) — A concrete defense based on separating control and data flow and enforcing capabilities.
5. Design Patterns for Securing LLM Agents against Prompt Injections (2025 preprint) — Alternative trust-boundary designs.
6. Security of AI Agents (2024 preprint) — Background on agent threat models and vulnerabilities.
7. Not what you’ve signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection (2023) — Attacks delivered through retrieved content and other untrusted data.
8. AgentPoison: Red-teaming LLM Agents via Poisoning Memory or Knowledge Bases (2024) — Attacks on persistent memory and retrieval-based agent knowledge.

Incident reports and containment failures

1. OpenAI–Hugging Face Incident Technical Report (OpenAI, 2026) — Evaluation containment, shared infrastructure, and monitoring failures.
2. Investigating three incidents in our cybersecurity evaluations (Anthropic, July 30, 2026) — Reported incidents involving unintended access to real systems during evaluations.
3. An alignment assessment of recent cybersecurity incidents (Anthropic, September 9, 2026) — Follow-up assessment, including a fourth incident and environment-boundary failures.

1. Compare two cyber reasoning system architectures in the AIxCC SoK. How do they combine LLM reasoning with conventional analysis and testing, and what tradeoffs arise in orchestration, reliability, and resource use?
2. Why is generating a patch that stops a known proof of vulnerability insufficient to establish a correct repair? What additional validation and measurements would you require before deployment?

Autonomous investigation and response

1. BlueSTAR: Tiered Agentic Architecture for Autonomous Cyber Defense (September 2026 preprint) — Tiered detection and response; evaluates attack impact and disruption caused by defenses.
2. Large Language Models are Autonomous Cyber Defenders (IEEE CAI Workshop on Adaptive Cyber Defense, 2025) — LLM/RL teams and communication in simulated incident response.
3. Cyber Defense Benchmark: Agentic Threat Hunting Evaluation for LLMs in SecOps (2026 preprint) — Threat hunting over security-event logs.
4. Trident: How to Break Deep Reinforcement Learning Cyber Defenses (Agentic) (August 2026 preprint) — Adaptive attackers as a test of learned defensive policies.

Vulnerability discovery, repair, and attack evaluation

1. Prompt Fuzzing for Fuzz Driver Generation (CCS ’24; PromptFuzz) — Fuzz-driver generation; a focused reference for the budget-aware fuzzing project.
2. CyberGym-E2E: Scalable Real-World Benchmark for AI Agents’ End-to-End Cybersecurity Capabilities (ICML ’26) — Evaluating discovery, reproduction, and patch generation together.
3. OSS-Fuzz-Gen: A Framework for Fuzz Target Generation and Evaluation (Google project documentation) — Harness generation, validation, and reproducible evaluation.
4. ELFuzz: Efficient Input Generation via LLM-driven Synthesis Over Fuzzer Space (USENIX Security ’25) — Coverage-guided synthesis of input generators.
5. EnIGMA: Interactive Tools Substantially Assist LM Agents in Finding Security Vulnerabilities (ICML ’25) — Interactive tools and evaluation of challenge-solving agents.
6. LLVM libFuzzer Documentation (LLVM documentation) — Coverage-guided fuzzing and harness fundamentals.
7. LLM Agents can Autonomously Exploit One-day Vulnerabilities (2024 preprint) — Agent exploitation given vulnerability descriptions; examine the benchmark assumptions.
8. CVE-Bench: A Benchmark for AI Agents’ Ability to Exploit Real-World Web Application Vulnerabilities (ICML ’25) — Controlled exploitation benchmarks and evaluation of cyber capabilities.

Incident reports and defensive response

1. Anatomy of a Frontier Lab Agent Intrusion: A Technical Timeline of the July 2026 Incident (Hugging Face, July 27, 2026) — Victim-side reconstruction, AI-assisted investigation, containment, and remediation.
2. Disrupting the first reported AI-orchestrated cyber espionage campaign (Anthropic, November 13, 2025) — Provider-reported malicious use of agents and the response to the campaign.
3. Detecting and countering misuse of AI: September 2026 (Anthropic, September 2026) — Cyber-operation case studies, detection, and disruption; focus on the cyber sections.

1. How does OSWorld-Human distinguish task success, action efficiency, and end-to-end latency? Why can improving one metric leave the others unchanged?
2. Which costs account for the gap between human and agent task completion? Propose an experiment that separates unnecessary actions, model-inference latency, and environment/tool latency while holding task success comparable.

1. SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering (NeurIPS ’24) — Coding-agent interfaces and tool feedback.
2. From Imperative to Declarative: Towards LLM-friendly OS Interfaces for Boosted Computer-Use Agents (2025 preprint) — A systems interface alternative to step-by-step GUI control.
3. OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments (2024) — Environment and outcome-based evaluation.
4. SWE-agent: Agent-Computer Interface (Project documentation) — Concrete tool and feedback design choices.

1. Why might fully separating encoding, prefill, and decode be worse than colocating some stages? Explain how the workload mix and latency objectives should influence that choice.
2. What additional scheduling and buffering requirements arise when an agent streams speech or video rather than returning text after a static image input? Which of these are outside TriInfer’s evaluated scope?

1. vLLM-Omni: Fully Disaggregated Serving for Any-to-Any Multimodal Models — Multi-stage execution and heterogeneous stage resources.
2. Experience and Lessons Learned from Serving Multi-Stage Qwen3-Omni in vLLM-Omni — Stage batching, CUDA Graphs, incremental handoffs, and selective replication.
3. vLLM-Omni — Open-source implementation.
4. ModServe: Modality- and Stage-Aware Resource Disaggregation for Scalable Multimodal Model Serving (SoCC ’25) — Especially the workload characterization: modality mix, encoder costs, and stage-level resource allocation.
5. M*: A Modular, Extensible, Serving System for Multimodal Models (2026 preprint) — Component graphs, loops, parallel branches, and streaming across multimodal components.
6. Cornserve: A Distributed Serving System for Any-to-Any Multimodal Models (CAIS ’26 Demo) — Computation graphs and independent component scaling for any-to-any models.
7. Qwen2.5-Omni Technical Report (2025) — A concrete multimodal architecture and streaming output.
8. Moshi: a speech-text foundation model for real-time dialogue (2024) — Full-duplex, low-latency speech interaction.

1. Trace a model request and tool call through the harness. Which components own context construction, policy enforcement, execution, and session state? How do live events differ from recorded session events?
2. A tool changes an external service, then the harness crashes before recording the result. What can session replay recover, and what additional support is needed to avoid repeating the action? How does a session fork differ from an execution-environment snapshot?
3. What should a meta-harness standardize across different agent harnesses, and which capabilities or guarantees must remain explicit? Give an example involving cancellation, permissions, or workspace state.

1. DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression — Section 5.3.5: Agent Team runtime and critical-path latency in collaboration training.
2. Introducing Omnigent: A Meta-Harness to Combine, Control and Share Your Agents (Databricks) — Composing existing harnesses through shared session and runtime services; open-source project.
3. Scaling Managed Agents: Decoupling the Brain from the Hands (Anthropic, 2026) — Separating the session log, harness, and sandbox for recovery and credential isolation.
4. Effective Harnesses for Long-Running Agents (Anthropic, 2025) — Incremental work, verification, and artifacts across context windows.
5. DeepSeek Harness: Tool Execution Pipeline — Policy hooks, guarded dispatch, and result recording.
6. DeepSeek Harness: Agent Teams — Experimental coordination runtime with persistent identities, mailboxes, and revisioned task state.
7. Meta-Harness: End-to-End Optimization of Model Harnesses (2026 research project) — A distinct meaning of meta-harness: optimizing harness code using execution feedback; paper.

1. How does METIS use profiling to choose a RAG configuration while scheduling queries? Why is retrieval quality alone insufficient for optimizing the complete application?
2. Design a comparison between fixed and adaptive RAG configurations. How would you prevent apparent latency improvements from coming entirely from lower answer quality or an easier query mix?

1. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (2020) — RAG model and retrieval fundamentals.
2. Quake: Adaptive Indexing for Vector Search (OSDI ’25) — Index adaptation and retrieval performance.
3. HedraRAG: Coordinating LLM Generation and Database Retrieval in Heterogeneous RAG Serving (SOSP ’25) — Joint retrieval and generation scheduling.
4. CacheBlend: Fast Large Language Model Serving for RAG with Cached Knowledge Fusion (2024 preprint) — Reusing KV state of retrieved content.

1. Why can separating prefill and decode improve goodput under TTFT and TPOT constraints? When might KV-cache transfer and resource fragmentation outweigh the benefit?
2. How would prefix reuse affect the placement of prefill work in a disaggregated system? Explain why always choosing the endpoint with the longest matching prefix can be a poor scheduling policy.

1. Kimi K3: Open Frontier Intelligence — Section 5.4.1 and Figure 12: jointly reusable KDA/MLA state; prefix hashing versus physical allocation.
2. NVIDIA Dynamo: Architecture — KV-aware routing, disaggregated prefill/decode workers, and NIXL transfer.
3. Dynamo: KV-Aware Router — Cache locality and current worker load in placement decisions.
4. Preble: Efficient Distributed Prompt Scheduling for LLM Serving (ICLR ’25) — Prefix locality versus load balancing.
5. Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving (FAST ’25) — KV-cache-centric architecture and distributed reuse.
6. POD-Attention: Unlocking Full Prefill-Decode Overlap for Faster LLM Inference (ASPLOS ’25) — A complementary approach that overlaps phases on a GPU.
7. Prefill-Decode Aggregation or Disaggregation? Unifying Both for Goodput-Optimized LLM Serving (2025 preprint) — When aggregation and disaggregation should coexist.

1. Why does MegaScale-Infer separate attention from expert computation? How do different parallelism strategies and its communication design make that separation useful?
2. How would longer contexts change the memory and communication demands of an MoE serving system? Distinguish KV-cache movement, attention computation, and token routing to experts.

1. DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression — Sections 2.2–2.3 and 3.2: asymmetric prefill/decode, shared/compressed global KV, cache lifetimes, and approximate bounded replay.
2. LoongServe: Efficiently Serving Long-Context Large Language Models with Elastic Sequence Parallelism (2024) — Long-context inference, elastic parallelism, and KV-cache migration.
3. LServe: Efficient Long-sequence LLM Serving with Unified Sparse Attention (2025) — A complementary sparse-attention design.
4. Optimizing Long-context LLM Serving via Fine-grained Sequence Parallelism (2025 preprint) — Tetris: a newer extension of dynamic sequence parallelism.
5. Taming Latency-Memory Trade-Off in MoE-Based LLM Serving via Fine-Grained Expert Offloading (fMoE, 2025) — Expert residency, offloading, and latency/memory tradeoffs.

1. Why can a request-level scheduler produce poor end-to-end latency for an agent program? What program-level information does Agentix expose, and how does it affect scheduling?
2. What additional runtime responsibilities arise when an agent pauses for a slow tool, is cancelled, or retries an action? Distinguish model-serving optimization from session and side-effect management.

1. Kimi K3: Open Frontier Intelligence — Section 5.4.3: cache affinity, failover, and request-class admission budgets.
2. DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression — Section 5.1.3: DSec placement, local admission, NUMA containment, and interference control for training/evaluation sandboxes.
3. Full-Stack Optimizations for Agentic Inference with NVIDIA Dynamo — Agent hints, request priority, cache retention, and tiered KV storage.
4. InferCept: Efficient Intercept Support for Augmented Large Language Model Inference (ICML ’24) — Tool pauses and retained inference state.
5. Parrot: Efficient Serving of LLM-based Applications with Semantic Variable (OSDI ’24) — Application-level dependencies exposed to the serving engine.
6. Conveyor: Efficient Tool-aware LLM Serving with Tool Partial Execution (2024) — Overlapping model generation with tool work.
7. Host Agent or Tools with Amazon Bedrock AgentCore Runtime (AWS documentation) — Production runtime and session-management case study.

1. How does PipeDream reduce pipeline bubbles, and what consistency tradeoff follows from overlapping work on different minibatches?
2. Compare the resource demands of inference, backward computation, and optimizer state. Which new scheduling challenges arise when training alternates with variable-length agent rollouts?

1. Kimi K3: Open Frontier Intelligence — Sections 5.2–5.3: expert balance, training memory, partial rollouts, external KV storage, and rollout throttling.
2. Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism (2019) — Tensor parallelism as a complement to pipeline parallelism.
3. ZeRO: Memory Optimizations Toward Training Trillion Parameter Models (2020) — Partitioning optimizer, gradient, and parameter state.
4. HybridFlow: A Flexible and Efficient RLHF Framework (2024 preprint) — Distributed RLHF execution and placement.
5. StreamRL: Scalable, Heterogeneous, and Elastic RL for LLMs with Disaggregated Stream Generation (2025) — Rollout/training disaggregation and elasticity.
6. AReaL: A Large-Scale Asynchronous Reinforcement Learning System for Language Reasoning (2025) — Asynchronous rollout and learning.

1. Choose two of Lampson’s design hints and connect each to a concrete system studied in this course. Where does the hint help, and where does applying it require care?
2. Using your project as an example, identify one abstraction or measurement that changed your design. Explain the tradeoff and what evidence would make you choose differently.

1. End-to-End Arguments in System Design (Saltzer, Reed, and Clark, 1984) — Where a function or guarantee belongs.
2. The Tail at Scale (Dean and Barroso, 2013) — Tail latency in large composed services.
3. Hidden Technical Debt in Machine Learning Systems (2015) — System-level costs beyond model implementation.