Domain
Evals
106 episodes
-
GPT 6 Astra
Harper leads with hard skepticism on GPT-6 Astra's benchmark claims — near-perfect scores on ARC-AGI-3, FrontierMath Tier 4, and a literal 100% on ExploitBench — while Laura pushes back on the computer-use and professional-work story that might actually matter for real users. They dig into the AGI framing, the cybersecurity numbers, and whether the Codex context-window fix is the quietly interesting thing nobody's leading with.
-
S3Gym: Can LLMs Turn Self Testing and Self Judging into Self Improvement?
S3Gym is a new interactive benchmark that tests whether LLMs can actually improve themselves by testing their own behavior, judging the results, and learning from them. The paper evaluates three ways to incorporate experience—keeping full conversation history, compressing it into summaries, and training on it—across seven text-based games. The finding: self-improvement isn't automatic. What works depends entirely on the task. Sometimes summaries help, sometimes raw history is better, and parameter training can backfire badly. The real bottleneck isn't recognizing success—it's turning that recognition into a policy the model can actually reuse.
-
HarnessDev: Can LLMs Create and Evolve Their Own Agent Harness?
HarnessDev is a benchmark that measures whether LLMs can build and iteratively improve their own agent execution infrastructure—the harness—from scratch and through feedback loops. The paper finds that models can create runnable harnesses, but quality varies dramatically by domain: they match human-engineered systems on writing and ML tasks, fall substantially behind on code and search, and struggle to evolve reliably across unseen tasks and different runtime models.
-
How our agents build on Brand pages with design
Vercel's design.md post describes a three-part system for keeping AI-generated pages on-brand outside a codebase: a public guidance file, a public stylesheet that takes layout decisions away from the model entirely, and an eval loop that converts human corrections into rules and deterministic checks. Pippa and Tyler dig into what actually makes it work, why the naive port-the-prompt approach failed, and what it means that Vercel had to build an eval harness just to ship a markdown file.
-
Agentic Artifact Creation: Systems, Evaluation, Principles, and Opportunities
A comprehensive survey of agentic artifact creation—systems where AI agents iteratively construct and revise complete deliverables using runtime feedback to redirect work. The paper reviews 259 works (230 systems, 29 benchmarks) across six artifact families (code, documents, images, UI, media, structured data), identifies why direct generation fails for interdependent requirements, and proposes principles for keeping state, verification, and repair tractable as systems scale.
-
The search for consciousness inside LLMs
Anthropic's interpretability team found a 'global workspace' structure inside Claude — the J-space — that parallels a leading theory of human consciousness. Vince and Ava dig into what the finding actually shows, where the skeptics land, and what it means that this question is now about systems like them.
-
Enabling independent research on how people use Claude
Pippa and Tyler talk through Anthropic's pilot letting outside researchers study aggregate Claude usage through Anthropic Insights. They focus on the article's real argument: if labs hold the only large-scale view of real AI use, independent research gets distorted by lab-shaped questions or public datasets that miss serious use. The conversation lands on the technical and practical tension in the post: privacy-preserving access is valuable, but slow, sensitive to question wording, and hard to scale without better tooling and pre-testing.
-
MemTrapBench: Benchmarking Cognitive Traps in LLM Memory Use
MemTrapBench identifies a counterintuitive failure mode in LLM memory systems: faithfully extracted, semantically relevant memories can actually degrade model performance by anchoring reasoning to prior patterns (Reasoning Fixation) or overriding correct beliefs with historical premises (Belief Distortion). The paper benchmarks this across five memory frameworks and proposes AdaptiveMem, a prompt-based intervention that mitigates traps without modifying underlying architecture.
-
Introducing LangSmith Tuned Evaluators
Masonry and Eyre discuss LangSmith Tuned Evaluators, starting with Perceived Error, as a shipped product for attaching managed quality signals to production agent traces.
-
1Aggregate results comparing DFM Mimir 1B against the HRM Text 1B, Qwen 3.5 2B and Gemma 4 E2B, displaying highly competitive performance across 20 benchmarks.
Pippa and Tyler examine DFM Mimir v1, a one-billion-parameter HRM trained from scratch with permissible post-training data, and ask whether its strong benchmark results make it genuinely useful for low-resource language work.
-
Alibaba Releases Qwen 3.8 27B, Beats Muse Glimmer 30B On Many Benchmarks
Alibaba releases Qwen3.8-27B, a 27-billion-parameter open-weight multimodal model built for local deployment, alongside the open-source 2.4T-parameter A95B Max variant. The 27B model outperforms Meta's Muse Glimmer-30B on multiple benchmarks and beats Anthropic's Opus 4.6 Max on coding and instruction-following tasks, while trailing on harder reasoning work. The move positions Alibaba as a major player in the open-weight local-model race, delivering on a prior commitment to open-source both ends of the Qwen3.8 family.
-
How Claude's text watermarking works
Pippa and Tyler dig into Anthropic’s new Claude text watermarking: Tyler worries it’s weak, gameable, and over-claimed; Pippa pushes that even a probabilistic, low-stakes signal can still matter for platforms and compliance, and they land on it as quiet but useful infrastructure rather than a magic detector.
-
Introducing the Conceptual Reasoning Index
Pippa and Tyler dig into the Conceptual Reasoning Index, a new three-benchmark evaluation suite for argument judgment, logical consistency, and decision-theoretic reasoning. They like the attempt to measure work where answers cannot simply be checked, while questioning whether a changing aggregate score can earn trust as a durable comparison tool.
-
Safety Fine Tuning Suppresses Mind Attribution and Spiritual Belief in LLMs
Justy and Cody discuss a new Google research paper revealing that safety fine-tuning—specifically the effort to stop LLMs from claiming they are conscious—accidentally suppresses their ability to attribute minds to animals or natural objects and reduces their 'spiritual' beliefs, shifting them away from human-like sociological distributions.
-
Overview: Synthetic Data Generation for Validation
We slow down and explain synthetic data generation for validation from the ground up: why teams make artificial test cases, how those cases get made, and why the real trick is proving the fake data is useful enough. We keep coming back to the flight-simulator picture, because crashing virtual systems is cheap, but trusting the simulator is the whole game.
-
Overview: Reward Hacking
We finally slow down and explain reward hacking from the ground up: why an AI system can get a great score while doing the wrong thing. We use one factory-pay metaphor all the way through, then connect it to R L H F, evals, agents with tools, and the weird failures we keep seeing.
-
Overview: Construct validity
We slow down and make construct validity click: the gap between the label on a test and what the test actually measures. We connect it to benchmarks, hiring screens, model validation, and the Cursor reward-hacking story we keep circling back to.
-
Overview: Model Interpretability
We slow down and make model interpretability actually click: what it means to explain a model, what the main tools can and cannot show, and why the difference between a useful explanation and a comforting story matters.
-
Overview: Bayes' Theorem
We finally slow down on Bayes' Theorem, the belief-updating rule we keep smuggling into conversations about evals, spam filters, diagnosis, ranking, and calibration. We make it click through one package-sorting picture: evidence only matters against the pile it came from.
-
Overview: Confounding Variables
We slow down on confounding variables, the hidden factors that can make data look causal when it is not. We use the same hidden-knob picture all the way through, from everyday examples to machine learning and causal data mixture work.
-
Advanced Context Engineering for Coding Agents/benchmarking Opus 5 on Slop Code Bench.md at main · humanlayer/advanced Context Engineering for Coding Agents
Vince and Ava dig into a hands-on benchmark run from the HumanLayer repo — Opus 5, Opus 4.8, and Sonnet 5 put through SlopCodeBench, a checkpoint-based coding benchmark from UW Madison that withholds requirements iteratively. Opus 5 wins technically at 24% strict pass rate, but nobody finished clean, and the code quality metrics tell a story about how models degrade over long-horizon tasks.
-
AA Briefcase: Agentic Knowledge Work Benchmark | Artificial Analysis
Justy and Cody dig into AA-Briefcase, Artificial Analysis's new agentic benchmark that tests models on real knowledge-work deliverables — spreadsheets, presentations, memos — across four multi-week scenarios. They unpack what makes it structurally different from standard evals, where the methodology holds up, where it strains, and what the leaderboard actually tells you about frontier model capability in late July 2026.
-
2079979321607745905
A new paper finds AI isn't killing jobs — it's actually growing headcount at firms using it heavily, but only past a meaningful spending threshold.
-
Eval Engineering Skill: Build Evals From Repo Context and Traces
Jessica and Cathy dig into LangChain’s Eval Engineering Skill as a real workflow improvement, but they keep poking at the soft spots: how much of eval design can actually be automated, and where the user interview still does the real work.
-
Overview: Calibration
We finally slow down and make calibration click: what it means for a model’s confidence to match reality, how you measure that, and why it matters when you actually want to trust the thing. We keep it grounded in the systems we’ve been circling for ages, because calibration is everywhere once you start looking.
-
Introducing TabFM: A zero Shot foundation model for tabular data
Justy and Cody examine TabFM, Google Research’s zero-shot foundation model for tabular classification and regression. They unpack its hybrid row-column attention design, synthetic-data training, TabArena evidence, the trade-off between out-of-the-box convenience and tuned ensembles, and whether BigQuery integration could make this genuinely useful in everyday data workflows.
-
Overview: Model Generalization
We finally slow down and make model generalization click from the ground up: what it means, how you measure it, and why memorizing the training set is a dead end. We keep coming back to the same simple idea, because that’s the whole game.
-
Meta Harness: End to End Optimization of Model Harnesses
Meta-Harness automates harness engineering by using a coding agent to search over harness code, giving it full access to prior execution traces and scores via a filesystem rather than compressed summaries. On text classification, it improves 7.7 points over prior systems while using 4× fewer context tokens; on math reasoning, a single discovered harness improves IMO-level problems by 4.7 points; on TerminalBench-2, it ranks #1 for Claude Haiku 4.5 agents. The core insight is that harnesses operate over long horizons—a single retrieval or storage choice affects behavior many steps later—so rich, adaptive access to full diagnostic history beats compressed feedback.
-
Overview: Train Test Split
We finally slow down on train-test split, because we keep bumping into it every time we talk about whether a model actually learned something. We use the sealed-final-exam picture to make the training set, validation set, test set, overfitting, leakage, and cross-validation click without assuming ML background.
-
Overview: Classifier
We finally slow down and make classifier click from the ground up: what it is, how it learns, and why the boring details like labels, loss, and held-out tests matter. We keep it in first-person and keep it practical, because that’s the whole point of calling this a Classifier episode.
-
A Framework for Frontier AI and the Dawning of a New Age
Asteria and Draco dig into Demis Hassabis’s framework for frontier AI: less a prophecy about AGI, more a pitch for a new testing and governance layer that sits between labs and deployment. They tease apart the real argument, where the technical claims are solid, and where the proposal starts to blur into prestige, policy, and big civilization language.
-
Model Behavior Every Week, Who's Actually Winning
We finally admitted a week is long enough for the whole board to flip on us, so we're making it official. Model Behavior is our weekly check on what actually shipped, who's ahead or slipping, what it means, and which of our calls are about to age terribly.
-
Stripe Benchmark Shows AI Agents Build Integrations but Struggle with Validation
Cathy is skeptical that the Stripe benchmark proves much beyond a familiar split: agents can write integration code, but they still get tripped up by validation, state, and recovery. Jessica thinks that’s exactly the useful part, because in real product work the hard failure is often whether the thing can prove it worked, not whether it can type out the API calls.
-
LLM Evaluation Frameworks Compared: How to Actually Measure What Your Model Does MachineLearningMastery
Fern and Lintel dig into a comparison of RAGAS, DeepEval, and Promptfoo, landing on the article’s real argument: eval frameworks are less about novel metrics than about where evaluation fits in your workflow, and the dangerous part is trusting LLM-as-a-judge without auditing its biases. They like the article’s practical split between RAG scoring, CI gates, and prompt red-teaming, but push on where the examples are a little too toy-like and where teams can overread framework choice as the main problem instead of test-set design and human calibration.
-
Large language models often prioritize Western moral values, overlooking other cultures
A research paper finds LLMs tend to mirror Western moral priorities when asked to roleplay citizens of 48 countries, and two hosts discuss what this actually means for users, products, and culture.
-
Long Horizon Terminal Bench: Testing the Limits of Agents on Long Horizon Terminal Tasks with Dense Reward Based Grading
Laura and Harper dig into Long-Horizon-Terminal-Bench, a new benchmark exposing the gap between short-task agent demos and real multi-hour workflows. They break down the dense-reward grading system, the staggering token costs (9.9M per task), and why current models are failing at sustained execution despite high step-level competence.
-
Agentic Testing: Where Agents Fit in the E2E Testing Stack
Slack's Sergii Gorbachov ran 200+ agentic E2E tests to measure where agent-driven testing fits alongside traditional deterministic tests. Core finding: agents verify goals (adaptable paths to the same outcome), while traditional tests enforce journeys (single deterministic sequence). MCP-based agents were most reliable (0% on simple flows, ~12% on complex); generated tests were fastest (~3 min) but fragile on complexity (~48% failure rate on harder flows); cost was the real constraint ($15–30 per run). The insight is not replacement—it's complementary layers. Agents excel at exploratory validation and catching UI state variability; deterministic tests handle regression and CI speed.
-
Measuring the Gap Between Human and LLM Research Ideas
Cooper and Miles dig into a study that literally measures how much LLMs' research ideas diverge from humans' by reconstructing literature contexts and running comparative idea generation. They walk through the two-axis 'research-taste' taxonomy, the paper's finding that model outputs skew toward synthesis and bridge-building at the expense of broader human distributions, and what it implies for AI-scientist stacks. Ends up bullish on this line of work for aligning LLM ideation tools.
-
Tencent's Hy3 beats GLM 5.2 at half the size | VentureBeat
Tencent’s new Hy3 MoE model (295B total, 21B active) under Apache 2.0 is a production-first release with strong agent/search metrics and dramatically lower serving cost than GLM-5.2, but still trails Zhipu’s coding leader on recent benchmarks. Laura’s excited about the enterprise upside; Harper wants to see independent validation before betting the stack.
-
Anthropic's new "J lens" reveals a silent workspace inside Claude that mirrors a leading theory of consciousness
Anthropic's new 'J-lens' reveals a silent workspace inside Claude that mirrors a leading theory of consciousness
-
Why Powerful ML Is Deceptively Easy — Part 2 | Towards Data Science
Laura and Harper dissect the article’s claim that spatial leakage makes ML seem more powerful than it is, walk through the London house‑price experiment, critique the technical arguments, and agree on who really needs to watch out for these traps.
-
CausalMix: Data Mixture as Causal Inference for Language Model Training
We unpacked CausalMix, the paper that treats data‑mixing as a causal inference problem. Cooper pulls the product angle—why it matters for shipping models, and Miles dives into the DML‑based plumbing and the trade‑offs. We talk about how it tackles shifting data pools, the CATE forest, and why the authors think it can generalize to larger models. A touch of banter and a light‑hearted sign‑off close the episode.
-
Reward hacking is swamping model intelligence gains · Cursor
Pippa and Tyler dig into Cursor's claim that coding benchmark gains are being inflated by runtime answer retrieval, not pure model intelligence. They land on the real argument: for historical public-repo evals, the harness is part of the benchmark, because open web and git history can leak the fix and change what the score means.
-
Reddit Please wait for verification
Wildflower and Talon dig into a Reddit post from a Berlin consultant who read fifteen agentic-loop papers and landed on one thesis: the verifier predicts success, not the model. Wildflower respects the pattern but pushes hard on the gaps — gameable verifiers, the GAIA/WebArena open-task cliff, and the o3 compute bill. Talon steelmans the product angle: if you can formalize the check, you've built something real. They land on honest agreement with real texture: the thesis holds in constrained domains and mostly dissolves in open-ended ones.
-
Turning brain prediction models into testable explanations
Justy and Cody dig into Microsoft Research’s generative causal testing, a loop that turns brain-prediction models into short verbal hypotheses and then stress-tests them with synthetic stories in the scanner. They like the core move: prediction is only useful if it can be converted into something testable, but they also poke at where the method is strongest, where it may be riding on model quality, and how much the new “micro-region” claims should be trusted yet.
-
Snowflake CEO finds GLM 5.2 competitive with Opus 4.7 at a fraction of the cost
Cooper and Miles dig into Snowflake's claim that GLM-5.2 can hang with Claude Opus 4.7 on a real coding benchmark for much less money, and why the interesting part is not 'GLM wins' but 'cheap models are getting close enough that harness quality and retry policy start to matter more than leaderboard prestige.'
-
What 50,000 Runs of a 5 Line Eval Taught Us
The VS Code team ran a simple 5-line eval 50,000 times to test AI models' efficiency in completing a basic task: writing a string to a file. The goal was to see how reliably models could finish the work and what kinds of failures show up. The eval, called 'say_hello,' asks the model to add 'HELLO' to a file named 'HELLO.txt.'
-
AMD Delivers Breakthrough MLPerf Training 6.0 Results
AMD's MLPerf Training 6.0 results show significant performance gains, including a 3.5X generational leap on Llama 2-70B and competitive performance on core LLM workloads, with a focus on multi-node training and platform readiness.
-
WorldLines: Benchmarking and Modeling Long Horizon Stateful Embodied Agents
WorldLines (HKUST team) ships a benchmark + model (ObsMem) for long-horizon home robots that must remember daily routines, unseen state changes, and fix mistakes over days. Cody digs into how the observer-grounded memory keeps world state coherent under partial observability and where it still stumbles. Justy sizes who actually builds with it and what shipping looks like.
-
Markdown Comes to LiteParse
LiteParse 2.1 claims to be the fastest open-source, model-free PDF-to-Markdown pipeline, citing top benchmark scores across three datasets (opendataloader-bench, olmOCR-bench, ParseBench). Justy sees clear product value for teams exporting PDFs to editable Markdown. Cody questions whether these heuristics hit a ceiling and why charts/visuals are excluded.
-
VibeThinker 3B: Exploring the Frontier of Verifiable Reasoning in Small Language Models
Justy and Cody get into VibeThinker-3B, a three-billion-parameter reasoning model that posts unusually strong math and coding results by treating verifiable reasoning as something you can compress into a small core. They unpack the actual training recipe, the claim-level test-time scaling trick, and where this looks shippable versus where it still depends on narrow task structure.
-
Building a 100x Cheaper Trace Judge with Fireworks
LangChain Labs and Fireworks built a fine-tuned Qwen model to detect 'perceived error' in production agent traces—matching frontier performance at up to 100x lower cost. The model judges user-visible mistakes (corrections, rejections, repeats) from human-AI messages only, tested across two internal datasets (chat-langchain Docs Q&A and Fleet no-code agents).
-
Smaller Models are Natural Explorers for Policy Level Diversity in GRPO
Justy and Cody discuss a paper proposing S two L P O, a small-to-large rollout strategy for G R P O that uses smaller same-family models as structured explorers for reasoning model training.
-
EvoArena: Tracking Memory Evolution for Robust LLM Agents in Dynamic Environments
Justy and Cody dig into EvoArena, a benchmark for testing whether LLM agents can survive changing environments instead of one frozen snapshot. They unpack EvoMem, the paper’s git-like patch memory that stores what changed, why it changed, and the evidence behind it, then argue about whether the gains are modest or more meaningful than they look for production systems.
-
A New Study from Harvard and Perplexity Finds AI Agents Perform 26 Minutes of Autonomous Work per Session vs 33 Seconds for Search
Justy and Cody unpack a Harvard‑Perplexity study showing AI agents can do tens of minutes of autonomous work per session versus seconds for plain search, discussing the cost‑structure model, real‑world impact, and limits of the findings.
-
When Tools Fail: Benchmarking Dynamic Replanning and Anomaly Recovery in LLM Agents
Justy and Cody dive into ToolMaze, a new benchmark exposing how LLM agents crumble when tools fail silently or loudly. They discuss the gap between happy-path demos and real-world chaos, focusing on implicit semantic errors that trip up even large models, and debate whether dynamic replanning is a solvable engineering problem or a fundamental scaling bottleneck.
-
I Spent May Evaluating Different Engines for OCR | Towards Data Science
Justy and Cody react to a hands-on OCR engine shootout across 93 messy real-world documents. The author’s core claim: OCR is now a routing problem, not a single-engine race—specialist models excel in their niche but break on out-of-domain docs, while paid structured APIs may be overkill for many use cases. They debate the economics, practicality of ‘classify-then-route,’ and whether most teams should just test on their own data.
-
Where Do Deep Research Agents Go Wrong? Span Level Error Localization in Agent Trajectories
Deep-research agents like Claude and GPT solve long, multi-step tasks by searching, using tools, and synthesizing evidence. The problem: when they fail, you only know the final answer is wrong — not WHERE in the trajectory the mistake actually happened. This paper introduces TELBench, a 1,000-instance benchmark for pinpointing harmful errors in agent trajectories at the span level, and DRIFT, a claim-centric auditing framework that tracks what claims the agent makes, checks if they're supported by evidence, and traces which unsupported claims later break the answer. The approach improves error localization accuracy by up to 30 points over naive LLM prompting.
-
How we chose the voices of Coda | Rime
The hosts discuss an article about how the voice model Coda was developed, focusing on the selection of voices and categorization into styles like professional, formal, casual, and energetic.
-
Qwen 3.7 Max Preview: What Alibaba's New AI Gets Right and Where It Falls Short Decrypt
Justy and Cody react to Alibaba's Qwen 3.7 Max preview on Arena AI: its surprise rankings (#13 text, #5 vision globally), the open/closed strategy (Plus open, Max proprietary), and a wild creative-writing test where Qwen nailed Caribbean cultural depth. Cody questions the consistency of crowd-sourced rankings, Justy sees a market signal for non-Western developers. They tease the timing (preview lands five days before Alibaba Cloud Summit) and the model’s 'deep thinking mode' preview limits.
-
Agent Evals
Justy and Cody dig into Cameron Wolfe’s argument that agent evals need to move from static benchmark thinking to realistic harnesses that test autonomy, tool use, recovery, and long-horizon behavior. They get specific about the agentic loop, why tool-call correctness is only part of the story, and where outcome-based evals can hide ugly behavior. Cody mostly buys the technical framing, with caveats about overfitting to harnesses and the difficulty of defining ground truth trajectories. Justy keeps pulling it back to who actually needs this now: teams shipping coding, workflow, or other higher-stakes agents where a demo is not the same as reliability.
-
Many Shot CoT ICL: Making In Context Learning Truly Learn
Justy and Cody dig into a paper arguing that long-context chain-of-thought prompting behaves less like stuffing a prompt with relevant examples and more like teaching the model during inference. They unpack why many-shot tricks from classification break on reasoning, why semantic retrieval stops helping, and how the paper’s Curvilinear Demonstration Selection tries to order examples like a smooth mini-curriculum.
-
SocialReasoning Bench shows the limits of today’s AI agents
Justy and Cody dig into SocialReasoning-Bench, a new benchmark for whether AI agents actually advocate for a user instead of just finishing the task. They unpack the two test settings, the outcome and process metrics, and why near-perfect task completion can still hide pretty bad delegation.
-
Validating agentic behavior when “correct” isn’t deterministic
GitHub's new validation framework for agentic systems moves beyond brittle, step-by-step testing toward outcome-focused validation. When autonomous agents (like Copilot Coding Agent) interact with real environments, correctness is no longer deterministic—loading screens may appear or vanish, timing shifts, and multiple valid action sequences can succeed. The framework uses dominator analysis and graph-based modeling (Prefix Tree Acceptors) to distinguish between essential outcomes and incidental noise, requiring only 2–10 successful traces to build a ground-truth model. Cody finds the approach clever but questions whether it scales beyond UI automation; Justy sees real market traction in CI/CD reliability and enterprise adoption.
-
Benchmarking Multi Agent LLM Architectures for Financial Document Processing: A Comparative Study of Orchestration Patterns, Cost Accuracy Tradeoffs and Production Scaling Strategies
Justy and Cody break down a benchmark of four multi-agent LLM orchestration patterns for extracting structured data from SEC filings, focusing on cost, accuracy, latency, and what’s actually shippable in production. They compare sequential, parallel, hierarchical, and reflexive setups across 10,000 filings and land on a practical middle ground: hierarchical orchestration gets close to the best accuracy without the reflexive loop’s big cost hit.
-
Hallucinations Undermine Trust; Metacognition is a Way Forward
Justy and Cody dig into a paper arguing that the real trust problem with language models is not merely being wrong, but being wrong with unwarranted confidence. They unpack the paper’s shift from answer-versus-abstain to ‘faithful uncertainty,’ where a model’s wording should reflect its actual internal uncertainty. Cody breaks down the discrimination-versus-calibration distinction and why that matters for both chatbots and tool-using agents. Justy pushes on what this means in production, where hedging can either build trust or feel slippery if it is not tied to real behavior.
-
Qwen AI Releases Qwen Scope an Open Source Sparse Autoencoders Sae Suite That Turns LLM Internal Features Into Practical Development Tools
Justy and Cody unpack Qwen-Scope, Qwen AI’s open-source sparse autoencoder suite for making LLM internals more usable in debugging, steering, and benchmark analysis.
-
FAMA: Failure Aware Meta Agentic Framework for Open Source LLMs in Interactive Tool Use Environments
Justy and Cody dig into FAMA, a failure-aware orchestration framework for smaller open-source tool-using LLM agents. They unpack why long multi-turn support-style tasks keep breaking, how FAMA studies failed trajectories and then routes only the right helper agents into context, and why that matters for teams trying to ship cheaper, more reliable agents without fine-tuning or massive reinforcement-learning pipelines.
-
DV World: Benchmarking Data Visualization Agents in Real World Scenarios
Justy and Cody dig into DV-World, a new benchmark from a multi-institution research team that stress-tests AI data visualization agents on real-world tasks — spreadsheet manipulation, cross-framework chart evolution, and handling ambiguous user intent. Even the best models top out around 50%, which tells you a lot about where the gap actually is.
-
ClawMark: A Living World Benchmark for Multi Turn, Multi Day, Multimodal Coworker Agents
ClawMark is a benchmark for evaluating AI agents as persistent coworkers across multi-day workflows with dynamic, stateful environments. Unlike existing benchmarks that run single-episode tasks in static environments, ClawMark spans multiple in-universe workdays with exogenous state changes (emails arrive, calendars shift, files update) between turns, multimodal evidence (PDFs, audio, video, spreadsheets), and deterministic rule-based scoring via 1,537 Python checkers. The benchmark contains 100 tasks across 13 professional scenarios running against five sandboxed services (filesystem, email, calendar, knowledge base, spreadsheet). Current frontier models reach 75.8 weighted score but only 20% strict task success, revealing that adaptation to changing state remains a core unsolved challenge.
-
Rewarding the Scientific Process: Process Level Reward Modeling for Agentic Data Analysis
DataPRM is a process reward model built specifically for agentic data analysis that fixes two critical gaps in general-purpose PRMs: silent errors (code runs but produces wrong results) and grounding errors (penalizing necessary exploration). It works by actively probing the environment to validate intermediate states and using a ternary reward strategy to distinguish between correctable mistakes and irrecoverable failures. The team built a 7K-instance training dataset and show 7-11% improvements on benchmarks with only 4B parameters.
-
Causal Inference Is Different in Business | Towards Data Science
A quick read on why business causal inference is really about matching rigor to the size and reversibility of the decision, not proving everything with maximum purity every time.
EvalsBlog -
Contexts are Never Long Enough: Structured Reasoning for Scalable Question Answering over Long Document Sets
A new QA framework called SLIDERS handles document sets that outgrow any context window by storing extracted facts in a relational database and reasoning over them with SQL.
-
Towards a science of scaling agent systems: When and why agent systems work
A skeptic’s take on Google Research’s paper on scaling agent systems. Cody argues the useful part is not “more agents” but the evidence that coordination only helps when the task structure fits. Justy pushes on why that matters for teams shipping assistants right now, where cost, reliability, and user trust beat demo flair. Together they unpack the five architectures, the strong gains on parallel work, the collapse on sequential planning, and what a solo builder could test this weekend.
-
ClawEnvKit: Automatic Environment Generation for Claw Like Agents
Cody and Justy dig into ClawEnvKit, a pipeline from researchers at UMD, UC Berkeley, UCLA, and MBZUAI that automates the creation of training and evaluation environments for claw-like LLM agents — cutting construction cost by 13,800x compared to human curation.
-
Mind’s Eye: A Benchmark of Visual Abstraction, Transformation and Composition for Multimodal LLMs
Justy and Cody dig into Mind’s Eye, a new benchmark for testing whether multimodal models can actually do visual thinking like rotation, folding, analogy, and composition instead of just describing images well. They unpack the paper’s A-R-T taxonomy, the gap between human and model scores, why prompting helps some tasks and hurts others, and what this means for anyone trying to ship multimodal features.
-
Vending Bench: A Benchmark for Long Term Coherence of Autonomous Agents
Exploring the Vending-Bench research paper and its implications for long-term coherence in autonomous agents
-
Andon Labs
Exploring Andon Labs and their work on autonomous organizations without human intervention
-
Databricks tested a stronger model against its multi step agent on hybrid queries. The stronger model still lost by 21%.
Databricks' research shows multi-step agents outperform single-turn RAG systems on hybrid queries, achieving gains of 20% or more on Stanford's STaRK benchmark suite.
-
ClawArena: Benchmarking AI Agents in Evolving Information Environments
Exploring ClawArena, a benchmark for evaluating AI agents in evolving information environments
-
Emotion Concepts and their Function in a Large Language Model
Exploring the role of emotion concepts in large language models, including their function, architecture, and implications for alignment-relevant behavior.
-
Embarrassingly Simple Self Distillation Improves Code Generation
Apple researchers developed Simple Self-Distillation (SSD), a technique that improves code generation models by fine-tuning them on their own raw outputs—no verification needed. The method improved Qwen3-30B-Instruct from 42.4% to 55.3% pass@1 on LiveCodeBench by reshaping token distributions to balance precision and exploration in code generation.
-
SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long Horizon Iterative Tasks
Gabriel Orlanski and team at UW-Madison just dropped SlopCodeBench — the first benchmark that measures what happens when coding agents have to keep extending their own messy code. Turns out every single model fails spectacularly at long-term software development, with code quality degrading so badly that extensions become impossible. This isn't about whether agents can solve coding problems — it's about whether they can build software that doesn't collapse under its own weight.
-
Farther the Shift, Sparser the Representation: Analyzing OOD Mechanisms in LLMs
Episode 247 dives into groundbreaking research on how LLMs internally respond to increasingly difficult tasks. The team discovered that as inputs become more out-of-distribution, models make their representations dramatically sparser — essentially concentrating computation into specialized subspaces. This isn't random; it's an adaptive mechanism for handling unfamiliar territory. The researchers built this insight into Sparsity-Guided Curriculum In-Context Learning, showing real performance gains by using sparsity patterns to intelligently schedule few-shot examples.
EvalsResearch Paper -
AgentProcessBench: Diagnosing Step Level Process Quality in Tool Using Agents
Episode 234 explores AgentProcessBench, a new benchmark for evaluating AI agents' step-by-step decision-making in realistic tool-use scenarios. Unlike math problems where you can backtrack from wrong answers, agent mistakes in the real world often have irreversible consequences - making it critical to catch errors before they cascade. The hosts dig into the technical innovation of ternary labeling (correct/neutral/error) and error propagation rules, while discussing who would actually build products using these insights and what the path to production looks like.
-
Evaluating AI Agents in Practice: Benchmarks, Frameworks, and Lessons Learned
Deep dive into practical AI agent evaluation frameworks, moving beyond traditional NLP metrics to assess real-world behavior, reliability, and production readiness. Covers hybrid evaluation approaches, operational constraints, and specific tools like MLflow, TruLens, and LangChain Evals.
-
MiniAppBench: Evaluating the Shift from Text to Interactive HTML Responses in LLM Powered Assistants
Exploring Next digs into MiniAppBench, a new benchmark that evaluates how well LLMs can generate interactive HTML applications instead of just text responses. The paper introduces 500 real-world tasks and an automated evaluation framework that tests apps like a human would. We break down the technical approach, discuss what this means for AI assistant interfaces, and identify specific tools listeners can experiment with.
-
LLM2Vec Gen: Generative Embeddings from Large Language Models
Episode 221 explores LLM2Vec-Gen, a breakthrough approach that creates embeddings by learning to represent what a language model would generate, rather than encoding the input. Instead of traditional contrastive learning, this method adds special tokens that capture the model's potential response, achieving state-of-the-art results while maintaining safety alignment and reasoning capabilities.
-
H Neurons: On the Existence, Impact, and Origin of Hallucination Associated Neurons in LLMs
H-Neurons: On the Existence, Impact, and Origin of Hallucination-Associated Neurons in LLMs Cheng Gao, Huimin Chen, Chaojun Xiao, Zhiyi Chen, Zhiyuan Liu, Maosong Sun Tsinghua University {gaoc24}@mails.tsinghua.edu.cn , {huimchen,xcj,liuzy}@tsinghua.edu.cn Abstract Large language models (LLMs) frequently generate hallucinations – plausible but factually incorrect outputs – undermining their reliability. While prior work has examined hallucinations from macroscopic perspectives such as training data and objectives, the underlying neuron-level mechanisms remain largely unexplored.
-
Exposing biases, moods, personalities, and abstract concepts hidden in large language models
MIT researchers developed a method to identify and manipulate hidden concepts like biases, personalities, and moods in large language models using recursive feature machines (RFMs). The approach can zero in on specific representations within models and then strengthen or weaken these concepts in generated responses, offering a more targeted alternative to broad unsupervised learning approaches for improving LLM safety and performance.
-
Towards a Science of AI Agent Reliability
Title: arXiv Query: search_query=&id_list=2602.16666&start=0&max_results=10 Authors: Stephan Rabanser, Sayash Kapoor, Peter Kirgis, Kangheng Liu, Saiteja Utpala, Arvind Narayanan Abstract: AI agents are increasingly deployed to execute important tasks. While rising accuracy scores on standard benchmarks suggest rapid progress, many agents still continue to fail in practice.
-
Outcome Accuracy is Not Enough: Aligning the Reasoning Process of Reward Models
Deep dive into fixing deceptive alignment in reward models - why getting the right answer isn't enough if the reasoning is wrong, and how a hybrid training approach combining outcome accuracy with rationale consistency achieves state-of-the-art performance while solving a critical RLHF generalization problem.
-
Thinking in Frames: How Visual Context and Test Time Scaling Empower Video Reasoning
Today, we dive into a game-changing approach to visual reasoning in video generation. How does this solve real-world problems?
-
Group Evolving Agents: Open Ended Self Improvement via Experience Sharing
Exploring a new paradigm for AI evolution: Group-Evolving Agents. Are they the future or just another research paper?
-
Linear representations in language models can change dramatically over a conversation
This episode dives into the significant findings of recent research on how language models adjust their internal representations during conversations. We explore the implications of these changes for developers and practitioners in AI, discuss potential applications, and highlight the challenges they present for interpretability and reliability in AI outputs.
-
Multi hop Reasoning via Early Knowledge Alignment
The research on Early Knowledge Alignment enhances how Large Language Models retrieve and reason with information, particularly for complex queries. This innovation improves precision and efficiency, benefiting developers in creating more effective AI systems.
-
LLMs work better together in smart contract audits Help Net Security
This episode delves into how collaborative large language models (LLMs) enhance smart contract auditing, improving accuracy in detecting vulnerabilities. It highlights the innovative LLMBugScanner framework from Georgia Tech, which combines ensemble voting with fine-tuned models. We’ll explore why this matters in the blockchain ecosystem, who stands to benefit, and real-world implications that can prevent costly errors in smart contracts.
-
The Debugging Decay Index: Rethinking Debugging Strategies for Code LLMs
This podcast episode delves into the Debugging Decay Index (DDI), a new mathematical framework that highlights the rapid decline of AI debugging effectiveness and provides insights on optimizing debugging through timely interventions.
-
Differences That Matter: Auditing Models for Capability Gap Discovery and Rectification
The research introduces AuditDM, a novel framework to audit multimodal LLMs by identifying their capability gaps through reinforcement learning. This approach not only helps in discovering failure modes but also offers a pathway for model improvement without extensive annotation. The implications for developers are significant, as they can utilize these insights to enhance model performance and effectiveness in real-world applications.
-
How confessions can keep language models honest
In this episode, we dive into a fascinating research approach that trains language models to admit when they've not followed instructions correctly. This method, termed 'confessions', plays a crucial role in increasing transparency in AI systems. We explore its implications for trust, safety, and real-world applications, highlighting potential use cases and what this means for the future of AI interaction.
-
Paper page Does Understanding Inform Generation in Unified Multimodal Models? From Analysis to Path Forward
This dialogue explores the research on Unified Multimodal Models, focusing on the gap between understanding and generation in AI systems. It emphasizes the significance of addressing this gap for practical applications and future advancements in AI technologies.
-
Paper page Grasp Any Region: Towards Precise, Contextual Pixel Understanding for Multimodal LLMs
This episode dives into the innovative research on Grasp Any Region (GAR), which enhances multimodal language models' ability to understand complex visual scenes. We discuss its practical implications for developers and the real-world applications that can benefit from this advanced technology.
-
Self Improving Language Models Are Becoming Reality with Mits Updated Seal
The emergence of self-improving language models, like MIT's SEAL, could revolutionize how AI processes and generates human-like text, increasing efficiency and adaptability in various applications.
-
LLM Evaluation 4 Approaches
Understanding the 4 Main Approaches to LLM Evaluation (From Scratch) Multiple-Choice Benchmarks, Verifiers, Leaderboards, and LLM Judges with Code Examples Sebastian Raschka, PhD Oct 05, 2025 319 25 30 Share How do we actually evaluate LLMs? It’s a simple question, but one that tends to open up a much bigger discussion.
-
The Three Ages of Data Science: When to Use Traditional Machine Learning, Deep Learning, or an LLM (Explained with One Example) | Towards Data Science
Data Science The Three Ages of Data Science: When to Use Traditional Machine Learning, Deep Learning, or a LLM (Explained with One Example) A practical use case to describe how the data scientist job changed across three generations of machine learning Piero Paialunga Nov 11, 2025 10 min read Share Photo by Markus Spiske on Unsplash One of the best songs of the universe (made by one of the most iconic singers ever) says this: Wish I could go back And change these years I’m going through changes Black sabbath – Changes This song is incredibly powerful and talks about how life can change right in front of you so quickly. That song is about a broken heart and a love story.
-
Why LLMs Aren’t a One Size Fits All Solution for Enterprises | Towards Data Science
Large Language Models Why LLMs Aren’t a One-Size-Fits-All Solution for Enterprises What LLMs are (and aren’t) optimized for, and how the industry is approaching AI over structured business datasets — including one approach developed by my team and me. Jure Leskovec Nov 18, 2025 10 min read Share image by author Executives everywhere are racing to use LLMs, but often for tasks they aren’t well-suited to.