Domain
Evals
83 episodes
-
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.
-
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.