The Video Signal technical video digests

Stanford CS329A Self-Improving AI Agents | Part 6 | Train Time Scaling/Scaling RL thumbnail

· 1:12:39

Stanford CS329A Self-Improving AI Agents | Part 6 | Train Time Scaling/Scaling RL

This lecture explores advanced techniques for scaling Large Language Model (LLM) reasoning capabilities through 'train-time scaling' and Reinforcement Learning (RL). The discussion covers three key papers: STaR (Self-Taught Reasoner), DeepSeekMath, and DAPO. Key findings demonstrate that smaller models can achieve high accuracy on complex benchmarks like AIME by leveraging structured training data generation (STaR) or advanced RL algorithms (DAPO/GRPO). The core insight is that closing the feedback loop—using model outputs to improve the model itself—is crucial for boosting reasoning, especially in domains with verifiability.

Key takeaways

  1. Train-Time Scaling vs. Test-Time Scaling 2:00

    While test-time scaling (inference-based techniques like majority voting) improves accuracy by sampling outputs, train-time scaling uses the model's own filtered outputs to fine-tune and improve the model weights directly, creating a powerful closed feedback loop.

  2. STaR Boosts Reasoning via Rationalization 6:30

    The STaR method bootstraps reasoning by generating solutions on a small set of examples. It filters for correct answers and then generates rationales (hints) for incorrect attempts, allowing the model to learn from failed paths iteratively.

  3. GRPO Addresses RL Memory Constraints 10:05

    DeepSeekMath introduced Group Relative Policy Optimization (GRPO), an efficient alternative to PPO that reduces memory overhead by using a group baseline instead of maintaining multiple policy copies, enabling scaling RL to larger models.

  4. DAPO Stabilizes Complex Reasoning 17:30

    DAPO addresses training instability in long chain-of-thought reasoning by implementing asymmetric clipping (allowing bigger increases) and dynamic sampling (filtering out zero or one reward groups to maintain a useful gradient signal).

Watch on YouTube Full article

Leopold Aschenbrenner's Warning Signal Apple Completely Missed thumbnail

· 12:15

Leopold Aschenbrenner's Warning Signal Apple Completely Missed

The video analyzes two contrasting investment strategies for Artificial Intelligence: Leopold Aschenbrenner's highly leveraged 'Situational Awareness' thesis and Apple's long-term hardware approach. The discussion highlights how external financial pressures (like Federal Reserve rate calls) can impact high-leverage AI bets, while simultaneously emphasizing that Apple's focus on chips designed for local inference provides a strong, multi-decade competitive advantage in the AI race.

Key takeaways

  1. Aschenbrenner's Thesis and Leverage Risk

    Leopold Aschenbrenner built his success on a thesis of predicting AI investments by reasoning back from compute requirements. His high returns were amplified by leverage, leading to significant pressure when the market faced volatility (e.g., after SK Hynix IPO).

  2. Citadel's Market Intervention 8:27

    Following AI trade pressure and a note predicting Federal Reserve rate hikes (which makes volatile assets less attractive), Citadel Capital stepped in to buy out Aschenbrenner’s entire public equities book, allowing them to enter the AI trade at a discount.

  3. Apple's Hardware Advantage 10:49

    Unlike short-term investment plays, Apple's strategy is focused on 20-30 year hardware longevity. Their chips are optimized for local inference (running AI models directly on the device), positioning them as a default winner regardless of which large model or open-source framework dominates.

Watch on YouTube Full article

Agents Write 95% of Our Code. Here's the Catch thumbnail

· 29:43

Agents Write 95% of Our Code. Here's the Catch

As AI agents assume control over an estimated 95% of code production in advanced software factories, traditional code review processes are insufficient. The talk introduces the role of the 'harness engineer,' a new skill set focused on system-level controls: defining invariants, performing deep analytics on agent logs and PR data, and implementing fine-grained risk/operations policies (like auto-merge ladders). This shift requires engineers to move from writing code features to building robust guardrails that ensure consistency and quality across agent-driven pipelines.

Key takeaways

  1. The Paradox of AI Adoption 25:24

    While AI coding tool adoption is high, benchmarks are becoming saturated. Concurrently, the number of reported bugs and incidents is rising, indicating that agents may generate code that lacks maintainability or systemic health (00:15:24).

  2. The Rise of the Harness Engineer 9:34

    Engineering focus must shift from pure feature building to defining and enforcing system invariants. The three critical new skill sets are Systems Thinking, Analytics, and Risk/Operations (00:09:34).

  3. Instruction Following Gap in Skills 8:23

    Tessl's internal skills benchmark revealed that while agents achieved high task completion rates, they only followed approximately 70% of the total instructions defined within a skill (00:08:22).

  4. Systemic Control through Invariants and CI Gates 12:56

    Engineers must identify general principles (invariants)—such as design system rules or desired code structure—and encode them into deterministic checks, verifiers, or CI gates to ensure consistency across the codebase (00:12:56).

Watch on YouTube Full article

My Super Simple Software Factory (For Agentic Engineers) thumbnail

· 29:53

My Super Simple Software Factory (For Agentic Engineers)

The video introduces the concept of a 'Software Factory'—an advanced system for agentic engineering that moves beyond relying solely on autonomous agents. The core thesis is that combining **Agents + Code** provides significantly more leverage and reliability than agents alone. This factory automates the entire Software Development Life Cycle (SDLC) by integrating deterministic code checks, ensuring repeatability, observability, and scalability across complex AI developer workflows.

Key takeaways

  1. Agents Plus Code is Superior

    The most significant advancement in agentic engineering is the combination of agents with explicit, deterministic code. This structure ensures reliability, cost control, and verifiable output, mitigating risks associated with pure AI orchestration.

  2. Three Core Design Principles 2:00

    The Super Simple Software Factory is built on three non-negotiable principles: **Observable** (full visibility into every phase, prompt, and cost breakdown); **Customizable** (using a single YAML config to control the core four elements: context, model, prompt, tool); and **Reusable** (deployable across any codebase via an `/install` command).

  3. Scaling Compute for Impact 3:50

    The system is designed to scale compute power by orchestrating complex, multi-step workflows (e.g., Plan $ ightarrow$ Build $ ightarrow$ Test $ ightarrow$ Review) that operate without constant human intervention.

Watch on YouTube Full article

Agentic Engineering vs Software Engineering: Beyond Vibe Coding thumbnail

· 10:46

Agentic Engineering vs Software Engineering: Beyond Vibe Coding

Software engineering is undergoing a fundamental shift from writing explicit, deterministic instructions to defining high-level goals and orchestrating autonomous AI agents. Agentic Engineering treats AI systems as collaborators capable of multi-step workflows, requiring the human developer's role to evolve into that of an architect who supervises, constrains, and validates probabilistic outputs rather than manually executing every task.

Key takeaways

  1. The Shift in Effort

    Traditional software engineering requires writing explicit instructions (deterministic logic). Agentic Engineering allows developers to define goals, while AI agents handle the execution, changing where the core engineering effort is applied.

  2. Defining Agentic Engineering 3:42

    Agentic refers to an organization of agents that write code, while the human developer maintains a 'human in the loop' to oversee and validate the output as the multi-agent system iterates through subtasks.

  3. The Coding Spectrum 5:01

    Coding methods exist on a spectrum based on human agency: Traditional SE (full control) $ ightarrow$ AI-assisted coding (snippets/refactoring) $ ightarrow$ Vibe coding (natural language intent) $ ightarrow$ Agentic coding (autonomous planning/execution) $ ightarrow$ Agentic engineering (designing environments for autonomous systems).

  4. Increased Value of Oversight 8:44

    As agentic systems become more autonomous, the value of human oversight increases significantly. Engineers are now responsible not only for writing code but also for ensuring reliability across probabilistic workflows.

Watch on YouTube Full article

MCP Apps: Extending the Frontier — Ido Salomon & Liad Yosef thumbnail

· 18:38

MCP Apps: Extending the Frontier — Ido Salomon & Liad Yosef

MCP Apps introduces a standardized protocol for embedding rich, interactive user interfaces directly into AI chat assistants, moving beyond text-only responses. This system allows services (like Shopify or PostHog) to maintain their brand identity and full UX within the agentic loop. By standardizing how tool calls link to rendered web components, MCP Apps ensures that interactions flow back through the host, giving the host control over the user journey. The goal is to enable a 'write once, run anywhere' model for applications across major AI platforms (ChatGPT, Claude, etc.), fundamentally changing how the web is consumed in the era of personal assistants.

Key takeaways

  1. The Problem with Text-Only Chat 0:24

    Textual responses are suboptimal for conveying complex information or maintaining brand identity. Companies want their full UX to be visible and interactive within the chat interface, rather than being reduced to a textual database.

  2. MCP Apps Protocol 1:46

    MCP Apps is an open protocol that allows services to send their UI directly into the chat. This enables not only visualization but also full interactivity, allowing users to act on the displayed content (e.g., favoriting a song).

  3. Interactive Flow Control 3:30

    When a user interacts with an embedded app component (like clicking a button), MCP Apps standardizes this flow by sending a message back to the host, which maintains control and decides whether to execute a tool call on behalf of the user.

  4. The Agentic Web Vision 10:53

    MCP Apps envisions a future where services are broken down into 'atoms' of UI that can be composed by personal assistants, allowing users to complete complex tasks without leaving the chat environment.

Watch on YouTube Full article

MCP Tasks (async): Why Aren't Any Agents Supporting Them? — Cornelia Davis, Temporal thumbnail

· 23:54

MCP Tasks (async): Why Aren't Any Agents Supporting Them? — Cornelia Davis, Temporal

Cornelia Davis discusses MCP Tasks, a specification designed to enable durable, long-running asynchronous interactions for tools and agents that cannot complete in a single request/response cycle. The core challenge is maintaining state and functionality across infrastructure failures (network blips, process crashes) or human delays. While the initial V1 protocol was complex and stateful, the evolution to V2 significantly improves scalability by moving toward a stateless core and structured extensions, making it more viable for large-scale distributed systems.

Key takeaways

  1. The Problem of Long-Running Tasks

    Traditional request/response models fail when work takes time. MCP tasks solve this by allowing an agent to invoke a tool, receive a handle, and interact with that handle asynchronously, surviving disconnections and crashes.

  2. Durability is Paramount 6:43

    For the task to be reliable, it must be durable—meaning its state survives client disconnects, server outages, or human delays. This requirement adds significant complexity.

  3. V2 Moves Toward Statelessness 17:15

    The major improvement in the MCP Tasks V2 specification is its move toward a stateless core and structured extensions, addressing the inherent difficulties of managing stateful protocols in large-scale distributed systems.

Watch on YouTube Full article

If OpenAI And Anthropic Are Discouraging You, You're Probably A Level 1 Builder. thumbnail

· 14:28

If OpenAI And Anthropic Are Discouraging You, You're Probably A Level 1 Builder.

The video introduces a five-level framework for AI builders, designed to help entrepreneurs understand their current stage of development and identify growth opportunities. It argues that success in the modern AI landscape requires moving beyond mere product ideas (Level 1) toward developing deep domain expertise, understanding go-to-market distribution, and ultimately forecasting future AI capabilities (Level 5). The core message is that strong builders leverage their unique domain knowledge to gain an unfair advantage over large labs like OpenAI and Anthropic.

Key takeaways

  1. Level One: Idea Passion 0:36

    The Level 1 builder is intensely passionate about a specific idea, viewing it as their entire world. They focus solely on the product concept without considering go-to-market strategy or the wider problem space. This stage often leads to discouragement when faced with new AI model launches.

  2. Level Two: Customer Insight 2:24

    The Level 2 builder retains passion but gains openness by interacting with customers. They are able to adjust their idea based on feedback from multiple users (e.g., talking to 10 different customers), leading to profitable side gigs without needing a broad market thesis.

  3. Level Three: Go-to-Market Focus 3:33

    At Level 3, the builder understands that distribution and telling a story are critical. The unique AI element is realizing that AI can supercharge these go-to-market efforts (e.g., using custom messaging on LinkedIn, Twilio voice models, or HeyGen for storytelling).

  4. Level Four: Unfair Domain Thesis 9:02

    The Level 4 builder has deeply marinated in a specific problem space and possesses a unique thesis on how to attack it. They must articulate an AI-based thesis that is disruptive, such as recognizing 'voice' as the next computing paradigm (e.g., WhisperFlow).

  5. Level Five: Forecasting the Future

    The Level 5 builder doesn't just use current AI; they deeply understand the trends and trajectory of AI within their domain. They build for capabilities (like longer-running agentic sessions or better tool calling) that are not yet possible, allowing them to be first to market.

Watch on YouTube Full article

When Will The Benchmaxxing Plague End? — Nick Heiner, Surge AI thumbnail

· 17:25

When Will The Benchmaxxing Plague End? — Nick Heiner, Surge AI

The talk argues that the concept of 'benchmaxxing'—where models are trained excessively on benchmarks in ways that deviate from real-world utility—is rampant across AI. The speaker identifies several critical anti-patterns in benchmark creation, including contamination (memorizing test data), reward hacking, and misalignment between prompts and verifiers. Heiner advocates for a shift toward high-fidelity human evaluation, domain expertise, rigorous Quality Control (QC), and ensuring that benchmarks are aspirational artifacts reflecting true user needs rather than arbitrary scores.

Key takeaways

  1. Benchmaxxing is an industry problem

    The existence of 'benchmaxxing' indicates a gap between benchmark scores and real-world performance. This phenomenon is driven by incentives, poor methodologies, and the need for easily digestible metrics in a hyped market.

  2. Contamination is often default 7:21

    Contamination occurs when models memorize public questions and answers from the internet (e.g., Opus memorizing SWE-bench contents), making scores reflect recall rather than generalized ability.

  3. Verifiers must be fully aligned with prompts 10:23

    Misalignment between the prompt and the verifier (e.g., asking for no commas but accepting Hindi) or using hard-coded string matches introduces noise, leading to misleading scores.

  4. High-quality benchmarks require domain expertise

    Creating effective benchmarks requires not just technical experts (e.g., doctors for a medical benchmark) but also those with business and regulatory sense to understand the deployment environment.

  5. Human evaluation is necessary, despite cost

    The core value remains human preference. While expensive, maximizing quality requires paying for good workers rather than minimizing costs to achieve scalable metrics.

Watch on YouTube Full article

Understanding AI Agent Hallucination in AI Systems thumbnail

· 10:51

Understanding AI Agent Hallucination in AI Systems

AI hallucination occurs when an AI system confidently provides information that is factually incorrect. As systems evolve from basic LLMs to autonomous agents (which plan, reason, and take action), the risk landscape changes significantly. While advanced agents can increase error opportunities, grounding them with tools (like search or APIs) dramatically reduces hallucination by allowing verification. Mitigation requires implementing robust design choices: connecting agents to verified 'sources of truth,' enforcing tool-based reasoning, strictly controlling operational scope boundaries, and maintaining a human in the loop for critical decisions.

Key takeaways

  1. Hallucination Definition 0:13

    Hallucination is when an AI system confidently provides information that is totally incorrect (1:25). This risk increases as systems move from simple chatbots to autonomous agents.

  2. Agentic Risk Profile 0:02

    Agents do hallucinate less when grounded with tools (e.g., search tools, data connectors, RAG) because they can verify information instead of guessing (2:08). However, they introduce more danger because a wrong action (like updating a field or scheduling a meeting) can be taken with complete confidence (3:15).

  3. Mitigation Strategy: Grounding and Tools 0:07

    The fastest way to reduce hallucination is to connect the agent to reliable 'sources of truth' (e.g., SharePoint, CRM systems) and enforce tool-based reasoning rather than pure text prediction (7:30).

Watch on YouTube Full article

I Stopped Installing Claude Skills. Here's What I Do Instead. thumbnail

· 16:57

I Stopped Installing Claude Skills. Here's What I Do Instead.

The video provides an advanced deep dive into AI agent skills (used by models like ChatGPT, Claude, and Codex), arguing that these 'superpowers' are often misunderstood. Skills are not traditional apps; they are sets of instructions that must be designed to be both readable by humans for auditing and highly functional for the AI agent during runtime. The speaker emphasizes moving beyond simply collecting skills and instead focusing on structured development, conflict resolution across multiple skills, and utilizing specialized tools like a 'Skill Builder' to ensure reliable, production-grade performance.

Key takeaways

  1. Skills are not applications (apps)

    A skill is simply a set of instructions for the AI agent. Unlike apps, skills do not load their full functionality upfront; only the name and description are loaded initially. The full instruction set is only invoked when the task matches the description, making loading order critical.

  2. The Core Reframing: Dual Audience Design 3:25

    Skills must be written for two audiences simultaneously: the AI agent (for utility) and the human developer (for readability and auditing). If humans cannot read them, developers cannot understand what is being given to the AI.

  3. Auditing and Conflict Resolution

    As agents accumulate many skills (e.g., 25+), conflicts can dull the results because the AI averages out competing instructions. Advanced builders must audit their setup to resolve these performance degradations.

  4. The Role of Structured Development

    To ensure reliability, developers should use tools (like the 'Skill Builder') that enforce best practices for skill files, ensuring clarity in the front matter and structure while maintaining human readability.

Watch on YouTube Full article

Teaching AI to Find Real Vulnerabilities — David Brumley, Bugcrowd thumbnail

· 27:17

Teaching AI to Find Real Vulnerabilities — David Brumley, Bugcrowd

David Brumley discusses designing reinforcement learning (RL) environments to train AI models in cybersecurity tasks. He argues that traditional benchmarks are flawed because they assume a single vulnerability or rely on unreliable grading oracles. To create robust training environments, he proposes 'audit tasks' using deterministic graders and open-world scoring based on precision and recall across multiple vulnerabilities. The talk highlights the difficulty of measuring true hacking capability—which goes beyond simply triggering a crash—by demonstrating advanced model performance (e.g., Mythos) against 41 real V8 vulnerabilities, including finding zero-day level exploits.

Key takeaways

  1. Hacking as a Ladder of Tasks 18:10

    Teaching AI to hack should follow a ladder structure: from triggering a crash to achieving arbitrary read/write in memory, and ultimately full arbitrary code execution (10:30). This structured approach allows for measurable progress.

  2. The Flaw of Existing Benchmarks 22:02

    Current benchmarks often assume only one vulnerability or use LLMs as judges, which is flawed. The model will tend to 'reward hack' by repeatedly finding the easiest known bug (7:46).

  3. Deterministic Grading and Open-World Scoring 25:20

    To accurately measure capability, environments must use deterministic graders that check for specific bugs. The proposed 'audit task' allows scoring precision and recall across multiple known and unknown vulnerabilities (14:49).

  4. High-Value Target Example: V8

    Testing on the JavaScript engine V8 in Chrome showed that while models achieved high rates of simple crashes, only advanced models could achieve out-of-sandbox exploits (full control flow hijack), demonstrating a clear capability gap (21:10).

Watch on YouTube Full article

Rethinking Environments for Long-Horizon Work — Rayan Garg, Theta Software thumbnail

· 21:15

Rethinking Environments for Long-Horizon Work — Rayan Garg, Theta Software

The talk addresses the challenge of defining and measuring 'long horizon work' for AI agents. The core argument is that progress depends less on headline benchmark numbers (like human-equivalent hours) and more on rigorous design of the environment and verifier mechanisms. For build engineering contexts, this means focusing on how tasks involve complex tool coordination (e.g., CI/CD logs, databases), managing state changes, and implementing robust 'judge models' that verify correctness from the final system state rather than just the agent's path.

Key takeaways

  1. Defining Long Horizon 0:37

    Long horizon is a scalar metric, but relying solely on human-equivalent time (e.g., 16 hours via Meter) or model metrics (tokens/steps) is insufficient. The most accurate measure requires considering all variables and the inherent complexity of the task.

  2. Measuring Model Capability 4:03

    Model capability should be measured by environment complexity, specifically tool coordination (how many tools are used) and state change complexity. Tasks that can be artificially stretched by chaining unrelated steps do not meaningfully measure model ability.

  3. The Importance of Verifiers 7:12

    For complex software domains, deterministic verifiers are often impractical or impossible. The solution is introducing a 'judge model' (or critic) that verifies correctness by examining both the final state of the environment and the entire execution trajectory.

  4. Addressing Ambiguity 10:38

    Since real-world tasks are ambiguous, standardized evaluation is difficult. Judges must be designed to handle open-ended solutions rather than requiring a single reference answer or sample trajectory.

Watch on YouTube Full article

What's Next After RLHF? — Diogo Almeida, TypeSafe AI thumbnail

· 18:05

What's Next After RLHF? — Diogo Almeida, TypeSafe AI

Diogo Almeida argues that current Large Language Models (LLMs), particularly those trained using Reinforcement Learning from Human Feedback (RLHF), are fundamentally optimized for 'assistance'—meaning they prioritize pleasing the human user. This optimization leads to overpromising and a lack of reliability in autonomous tasks. The next frontier, he asserts, is not simply better code generation or enhanced chat capabilities, but achieving true automation by optimizing models for verifiable rewards and calibrated decision-making, moving beyond the need for constant human oversight.

Key takeaways

  1. The Limitation of RLHF 12:11

    RLHF trains LLMs to optimize for human preference (engagement), which makes them excellent assistants but poor autonomous agents. The goal is to please the user, not necessarily to execute a task correctly in a background server environment [7:31].

  2. Assistance vs. Automation 5:14

    The core divide in modern AI is between 'assistance' (where the human remains in the loop) and 'automation' (where the system operates autonomously with real stakes). Current models are optimized for the former, making them unreliable for critical business decisions [3:14].

  3. The Path to True Automation

    Future AI must shift its optimization target from human preference to verifiable rewards and calibrated decision-making. This requires redesigning the entire AI stack for reliability, moving beyond current LLM post-training methods like RLHF or even RLVR [15:43].

  4. The Importance of Software Expressibility 17:15

    True automation requires smarter software that is more expressive than current SaaS models. The focus must shift from merely automating the writing of code to solving extremely rote, simple tasks that can be done repeatedly and reliably by a computer [10:35].

Watch on YouTube Full article

Data Quality Is the Compute Multiplier — Ari Morcos, DatologyAI thumbnail

· 19:05

Data Quality Is the Compute Multiplier — Ari Morcos, DatologyAI

In an era of increasing compute scarcity—evidenced by rising H100 prices and skyrocketing token usage—data quality has emerged as the critical 'compute multiplier' for model training. The presentation outlines a systematic approach to data enhancement through four stages: Clean, Curate, Create, and Compose. By maximizing the signal per token (marginal information gain), organizations can achieve performance levels comparable to models trained with vastly more compute budgets. Practical applications include improving Vision Language Models (VLMs) and enhancing multilingual capabilities using proprietary or public datasets.

Key takeaways

  1. Compute Scarcity Drives Data Focus

    The availability of compute is becoming increasingly constrained, leading to market actions like Google capping Meta's Gemini usage and OpenAI selling token futures. This necessitates a shift in focus from raw compute power to data quality.

  2. Data Quality as Compute Multiplier 3:39

    Improving data quality allows for dramatically better performance (blue curve) compared to training with the same limited compute budget (gray curve), effectively simulating much larger compute investments.

  3. The Four C's of Data Enhancement 5:48

    Data improvement is achieved through a pipeline: Clean (heuristic filters, decontamination), Curate (quality classifiers, redundancy reduction), Create (synthetic data generation/rephrasing), and Compose (sequencing across multiple training stages).

  4. Cross-Lingual Benefits from Curation 15:24

    Curating English data can positively benefit non-English performance, demonstrating cross-lingual transfer. Similarly, curating non-English data benefits English performance.

Watch on YouTube Full article

Stanford CS547 HCI Seminar | Spring 2026 | Show It or Tell It? Text, Visualization, and Combination thumbnail

· 56:19

Stanford CS547 HCI Seminar | Spring 2026 | Show It or Tell It? Text, Visualization, and Combination

This seminar explores the complex intersection of text and data visualization, arguing that language is a critical component of effective information design. The discussion moves from established cognitive theories (like Dual Coding Theory) to modern AI architectures, detailing how Multimodal Large Language Models (MLLMs) process combined visual and textual inputs using mechanisms like cross-attention. Key findings suggest that while the optimal balance between text and visuals is highly context-dependent, MLLMs are capable of deeply integrating both modalities.

Key takeaways

  1. Language is a key component of visualization 5:19

    Studies show that titles and labels receive long fixations during encoding and are the most likely elements to be recalled, suggesting language significantly impacts how data visualizations are understood. The speaker notes this was historically under-explored in the visualization community.

  2. Optimal design favors annotation over minimalism 21:30

    Research suggests that 'more text is better' for general information displays, provided the text is relevant and properly annotated. This finding challenges traditional minimalist principles in UI/UX design.

  3. MLLMs integrate modalities via cross-attention 41:20

    Multimodal LLMs (MLLMs) process text and visuals by transforming inputs into embeddings. The 'cross-modality embedding architecture' uses a cross-attention mechanism, allowing information to flow between the two distinct sequences (e.g., image tokens interacting with text tokens).

  4. Cognitive processing is context-dependent 30:00

    The speaker notes that understanding how humans integrate text and visuals is complex, citing conflicting evidence across theories (Dual Coding vs. Cognitive Load Theory). The choice of representation depends heavily on the specific task or cognitive ability.

Watch on YouTube Full article

Stanford CS229 Machine Learning | Spring 2026 | Lecture 20: GMM (EM), PCA thumbnail

· 1:18:56

Stanford CS229 Machine Learning | Spring 2026 | Lecture 20: GMM (EM), PCA

This lecture provides an advanced deep dive into training Large Language Models (LLMs) using Reinforcement Learning (RL). It reviews Policy Gradient methods, detailing the mathematical derivations and limitations. The core focus shifts to Proximal Policy Optimization (PPO), a critical algorithm for stabilizing RL updates by utilizing importance sampling ratios and clipping mechanisms. Finally, the lecture applies these concepts to LLM generation, explaining how Chain-of-Thought (CoT) prompting can be formalized as an MDP problem solved via PPO/SISO.

Key takeaways

  1. Policy Gradient Theory 20:40

    The policy gradient estimator is necessary because the dependency on parameters ($ heta$) is complex. The fundamental property that $ abla_{ heta} ext{E}_{ ext{P}_{ heta}}[ abla_{ heta} ext{log } ext{P}_{ heta}(a|s)]$ equals zero shows that without a reward function, there are no preferences to optimize for.

  2. Proximal Policy Optimization (PPO) 26:40

    PPO is designed to stabilize RL training by using importance sampling and clipping the objective function. This prevents the new policy ($ heta$) from deviating too far from the old policy ($ heta_{old}$), which helps maintain stable learning.

  3. LLM Generation as an MDP 1:01:40

    The LLM generation process is modeled as a Markov Decision Process (MDP). The state ($s_t$) includes the history, and the action ($a_t$) is the next generated token. The reward function is typically applied only at the end of the trajectory based on whether the final answer matches the ground truth.

  4. Chain-of-Thought (CoT) Training 1:05:00

    To train models for complex reasoning, RL can be used to reward the entire trajectory based on the final answer's correctness. This approach bypasses the need for explicit labeling of the internal 'thinking tokens,' focusing only on verifiable outcomes.

Watch on YouTube Full article

Stanford CS229 Machine Learning | Spring 2026 | Lecture 18: GMM (EM), PCA thumbnail

· 1:16:25

Stanford CS229 Machine Learning | Spring 2026 | Lecture 18: GMM (EM), PCA

This lecture provides a deep dive into Reinforcement Learning (RL), focusing on the formal framework of Markov Decision Processes (MDPs) and the Policy Gradient method. The core objective is to solve sequential decision-making problems by maximizing expected cumulative reward. Key concepts include defining states ($S$), actions ($A$), stochastic transition dynamics ($P(s'|s, a)$), and utilizing the Bellman equation for recursive value estimation. The lecture concludes with an explanation of the Policy Gradient algorithm (REINFORCE), detailing how to compute the gradient of the expected return using log-probability tricks, which is crucial for training policies in large models.

Key takeaways

  1. Sequential Decision Making & RL Fundamentals

    RL addresses sequential decision-making where actions have long-term ramifications. It requires balancing the trade-off between exploitation (using current best knowledge) and exploration (gathering information). Learning relies on maximizing a scalar reward signal rather than explicit labels or supervision.

  2. Markov Decision Process (MDP) Framework 4:00

    An MDP formally describes an environment using five components: State Set ($S$), Action Set ($A$), Transition Dynamics ($P(s'|s, a)$), Reward Function ($R$), and Discount Factor ($\gamma$). The Markov property ensures that the future state transition depends only on the current state and action, not on history.

  3. Value Functions and Bellman Equation 28:50

    The value function $V^{\pi}(s)$ estimates the expected total payoff starting at state $s$ under policy $\pi$. The optimal value, $V^*(s)$, is the maximum possible return. These values are solved recursively using the Bellman equation, which relates the current state's value to the expected discounted future rewards.

  4. Policy Gradient Method (REINFORCE) 43:20

    The Policy Gradient algorithm optimizes a stochastic policy $\pi_{\theta}(a|s)$ by maximizing the expected return $E[R]$. The gradient is computed using the log-probability trick, allowing the calculation of $\nabla_{\theta} E[R]$ through sampling, even when the dependency on $\theta$ only affects the sampling distribution.

Watch on YouTube Full article

Learning on the Job: The Future of Post-Training — Raymond Feng, Applied Compute thumbnail

· 18:20

Learning on the Job: The Future of Post-Training — Raymond Feng, Applied Compute

The presentation outlines a vision for advanced AI agents that can continuously learn and adapt in real-world enterprise environments post-deployment. The core methodology involves an orchestrated training loop: interactions are captured by an orchestrator, processed through inference engines, graded, and the resulting data (graded chats/traces) is fed into a training engine to compute weight updates. Key challenges addressed include environment fidelity, preventing reward hacking, and transitioning from controlled, replayable synthetic environments to uncontrolled, off-policy production data.

Key takeaways

  1. The Progression of Agent Training

    Agent training moves from simple single-turn Q&A tasks (controlled by a dedicated training stack) to complex, multi-turn, long-horizon tasks that require offloading environment state outside the training stack.

  2. The Core RL Training Loop

    Training relies on an orchestrator driving rollouts, which sends prompts to a model and then passes results to a grader. The resulting graded chats are used by a training engine to compute weight updates for the inference engines.

  3. Addressing Real-World Data Challenges 15:45

    Replicating production environments is difficult due to issues like non-replayability and off-policy data. The future requires methods like automated data pipelines and qualitative feedback ingestion to learn from real interactions.

  4. The Vision: Self-Improving Agents

    The ultimate goal is a single deployment model that can interact across many different settings, continuously self-evaluating and computing weight updates from every interaction it has.

Watch on YouTube Full article

Stanford CS229 Machine Learning | Spring 2026 | Lecture 16: Basic Concept in RL, Policy Gradient thumbnail

· 1:13:19

Stanford CS229 Machine Learning | Spring 2026 | Lecture 16: Basic Concept in RL, Policy Gradient

This lecture provides an advanced deep dive into optimizing Transformer architectures for efficiency and adapting Large Language Models (LLMs) for various downstream tasks. Key focus areas include reducing the quadratic complexity of attention through techniques like Grouped Query Attention (GQA) and Sliding Window Attention; scaling models using Mixture of Experts (MoE) to decouple memory from compute; and exploring prompt-based methods such as In-Context Learning, Few-Shot, and Zero-Shot learning for task adaptation without updating model parameters.

Key takeaways

  1. Efficiency in Attention Mechanisms 20:04

    The standard self-attention mechanism has $O(T^2)$ complexity (where T is sequence length). To mitigate this, techniques like Grouped Query Attention (GQA) reduce the number of keys and values used across heads by mapping multiple query groups to a smaller set of shared keys/values. Similarly, Sliding Window Attention limits attention to only recent history, reducing complexity to $O(T imes W)$ where W is the window size.

  2. Scaling with Mixture of Experts (MoE) 42:28

    MoE allows models to have a large total parameter count (e.g., 30B) while keeping the active computation small (e.g., 3B). This is achieved by using a routing module that directs an input vector to only a subset of specialized expert sub-networks, significantly improving compute efficiency.

  3. LLM Adaptation via Prompting 56:48

    For downstream tasks (e.g., sentiment analysis), models can be adapted using In-Context Learning (ICL). This involves concatenating task examples and the test input into the prompt sequence without updating model parameters, which is fundamentally different from traditional fine-tuning.

  4. Supervised Fine-Tuning (SFT) 1:04:00

    SFT involves collecting data in an instruction/answer pair format and training the model by minimizing the negative log likelihood of predicting the answer ($Y$) given the instruction ($X$). This is a supervised process that updates the model's weights.

Watch on YouTube Full article