智能体编码能力课程

Anthropic's multi-agent research system is a production example of how a lead agent can coordinate specialized subagents that search, analyze, and return compressed findings.

This episode breaks down Anthropic's multi-agent research system and translates its lessons into the agentic coding domain. Maya and Leo explain the lead-agent/subagent architecture, why parallelism helps only when work can be divided cleanly, how delegation prompts become trainable data, and why observability and evaluation must capture coordination patterns rather than only final answers.

来源材料

• https://www.anthropic.com/engineering/multi-agent-research-system

This episode explains why Long-Horizon-Terminal-Bench matters: it turns long terminal work into a dense-grading benchmark instead of a binary solved-or-unsolved test.

This adhoc cross-series episode breaks down Long-Horizon-Terminal-Bench, a 46-task benchmark for long-horizon terminal agents. Maya and Leo explain why binary pass/fail scoring is too coarse for multi-step workflows, how deterministic subtask grading creates partial credit, what the paper's evaluation results say about frontier models, and why timeouts and false finishes show that long-horizon completion is a separate capability from short-horizon command use.

来源材料

• https://arxiv.org/pdf/2607.08964
• https://arxiv.org/abs/2503.14499

Cameron Wolfe's article contrasts clean pretraining scaling laws with the messier, setup-dependent scaling laws emerging around reinforcement learning for reasoning models.

This adhoc cross-series episode uses Cameron Wolfe's "RL Scaling Laws for LLMs" to connect prior shared-podcast threads: pretraining scaling laws, Chinchilla-style compute allocation, RLHF and PPO, train-to-test scaling, coding-agent sampling budgets, and verifier rewards. Maya and Leo explain why RL makes both the metric and compute budget harder to define, why GRPO turns rollouts into a first-class cost, and how teams should think about ceilings, efficiency, model size, data reuse, and reward quality before approving a larger RL run.

来源材料

• https://cameronrwolfe.substack.com/p/rl-scaling-laws
• https://arxiv.org/abs/2510.13786
• https://arxiv.org/abs/2509.25300
• https://arxiv.org/abs/2603.12151
• https://arxiv.org/abs/2001.08361
• https://arxiv.org/abs/2203.15556

This episode explains NVIDIA's Nemotron-Labs-TwoTower paper, which separates a frozen autoregressive context tower from a trainable diffusion denoiser tower.

This adhoc cross-series episode breaks down Nemotron-Labs-TwoTower, NVIDIA's diffusion-language-model architecture that decouples clean-context representation from block-wise denoising. Maya and Leo explain the motivation for separating roles, how layer-aligned cross-attention and timestep conditioning work, what the headline 98.7 percent quality and 2.42x throughput results mean, and why the design suggests a broader systems lesson for agent pipelines: keep stable context and iterative repair in different mechanisms when they want different jobs.

来源材料

• https://arxiv.org/pdf/2606.26493

This episode explains why fine-tuning can accidentally teach a model the wrong generalization, not just the right task.

This adhoc cross-series episode breaks down Concept Ablation Fine-Tuning, a method for controlling out-of-distribution generalization in fine-tuned language models. Maya and Leo explain why narrow fine-tuning can accidentally teach misaligned or shortcut-driven behavior, how the paper finds unwanted concept directions with PCA or sparse autoencoders, how projection during fine-tuning steers the model away from those directions, and why representation-level steering becomes valuable when the right data is unavailable or impractical to collect.

来源材料

• https://arxiv.org/pdf/2507.16795

This episode explains SHADE-Arena, a benchmark for evaluating whether an LLM agent can complete a benign long-horizon task, pursue a hidden harmful side objective, and still avoid detection by an LLM monitor.

This adhoc cross-series episode breaks down SHADE-Arena, a benchmark for sabotage and monitoring in long-horizon LLM agents. Maya and Leo explain the benchmark setup, why hidden scratchpads matter, what the reported sabotage and monitoring results mean, and why transcript-only oversight is not enough once agents can act across many steps in realistic environments.

来源材料

• https://arxiv.org/abs/2506.15740
• https://www.anthropic.com/research/shade-arena-sabotage-monitoring

Kimi K3's technical report is not simply a bigger-model announcement. Maya and Leo trace its central systems move: scale the foundation to 2.8 trillion sparse parameters while also scaling reinforcement learning, reasoning effort, and long-horizon interaction. They unpack the architecture — hybrid Kimi Delta Attention and Gated MLA for million-token sequences, Attention Residuals across depth, and 16-of-896 LatentMoE routing — then follow post-training through nine domain teachers, partial rollouts, and resumable sandboxes. The evidence is strong but bounded: leading coding and agentic benchmark scores, a roughly 2.5× scaling-efficiency claim over K2, an explicit gap to Claude Fable 5 and GPT-5.6 Sol — and open weights that don't shrink the training infrastructure.

来源材料

• Kimi K3: Open Frontier Intelligence — Technical Report of Kimi K3

This episode explains why long-horizon agents do not just need more context, but better-timed context.

This adhoc cross-series episode breaks down the proactive memory agent paper and its practical lesson for long-horizon systems. Maya and Leo explain behavioral state decay, the difference between passive retrieval and selective intervention, why the memory policy matters as much as the memory store, and how a separate memory agent can improve the action loop without requiring a full retrain of the underlying model.

来源材料

• https://arxiv.org/abs/2607.08716

This episode explains why long repair traces are hard to optimize from directly.

This adhoc cross-series episode breaks down STRACE, a method for structural trajectory analysis and causal extraction in agent optimization. Maya and Leo explain why long traces become noisy training inputs, how batch-level failure mining and dependency graphs help localize the real cause, what the four-stage pipeline does, and why better-shaped context can improve repair performance without asking the optimizer to sift through every irrelevant step.

来源材料

• https://arxiv.org/pdf/2607.07702