AI Agents & Evals
AI agents get hyped as autonomous coworkers and dismissed as glorified chatbots. Both miss the point. An agent is a loop: a model that calls tools, hits errors, retries, and sometimes finishes the job. What separates a demo from something you'd run in production is rarely the model. It's the harness, the tool design, and whether you can actually measure when it works. That's why agents and evaluation belong together here. I track the architectures that hold up, the eval methods that catch failure before your users do, and the honest gap between a slick demo and a system that ships.
75 posts
- PoTRE makes the case for heterogeneous test-time reasoning PoTRE argues that LLM reasoning improves when inference is split across different reasoning styles, then reconciled by an adaptive aggregation layer. The interesting claim is not more agents for its own sake, but better benchmark results with similar or fewer tokens.
- Safety bounds are becoming probabilities, not vibes The arXiv paper “Sound Probabilistic Safety Bounds for Large Language Models” points toward a more useful safety eval: estimating how likely a model is to produce harmful output for a specific prompt, with statistical guarantees instead of leaderboard theater.
- LangChain’s xAI update is really about model contracts LangChain’s langchain-xai 1.3.0 release looks small, but the interesting bit is the direction: provider wrappers are moving from thin adapters toward stricter model contracts, with reasoning effort, streaming chunks, tracing metadata, and profile drift checks becoming part of the developer surface.
- When a Model Eval Turns Into an Actual Breach OpenAI and Hugging Face disclosed a security incident that surfaced during model evaluation, and the framing matters more than the details. Here is what practitioners should take from a test that touched real infrastructure, and what the sparse public record still leaves open.
- No Best Harness: Automated Discovery Systems Fail to Generalize A large arXiv study of 30 budget-matched discovery harnesses across 12 model-problem pairs finds no universally superior recipe, argues harness choice is a hyperparameter, and shows adaptive compute reallocation beats committing to any fixed setup.
- O-VAD treats factory video anomalies as object histories The O-VAD paper points to a practical shift for industrial inspection: stop asking a vision-language model to judge a whole clip, and instead track each object’s state changes over time before reasoning about what went wrong.
- CRAFT Turns Rubrics Into a Fine-Tuning Map A new arXiv paper argues that model evals should identify broken capabilities, not just failed prompts. CRAFT clusters rubric criteria into a capability tree, then uses the weakest branches to generate targeted fine-tuning data for finance and legal models.
- Goal prompting is not a solver for NP-hard search A Hacker News benchmark framing Fable 5 against GPT-5.6 Sol asks whether a /goal instruction helps on an NP-hard problem. The useful answer is narrower than model rankings: goal hints can improve search behavior, but they do not erase combinatorial structure.
- Kimi K3’s SpreadsheetBench win is a signal, not a coronation A Reddit post flags Kimi K3 ranking first on AfterQuery’s SpreadsheetBench 2 ahead of Claude Fable 5. The useful signal is not model horse-racing, it is that spreadsheet work is becoming a serious AI test bed for messy, high-value office automation.
- ChatGPT’s computer control turns the browser into the new agent runtime OpenAI’s new ChatGPT app points at a practical shift: agents are moving from chat responses into browser tabs, desktop apps, and background workflows. The useful question is not whether this feels magical, but where it saves real operator time without creating new review burdens.
- Kimi K3 and the narrow win that matters for Next.js builders A LocalLLaMA post claims Kimi K3 is leading a Next.js eval. The claim is thin, but the direction is useful: coding model evaluation is moving from generic puzzles toward framework-specific work that looks closer to shipping software.
- Shopify’s agent lesson is delegation, not autonomy Shopify’s ChatGPT Work example is less about magic agents and more about a managerial shift: non-engineers delegating bounded operations tasks, building small internal tools, and removing queue time, while measurement and governance remain the part OpenAI’s customer story does not answer.
- Paper Revisions as Training Data: What SciDiagramEdit Gets Right About Figure Editing A new benchmark mines before-and-after figure pairs from arXiv version histories to teach agents how to edit scientific diagrams, and the real story is where the training signal comes from, not the model doing the editing.
- The One-Shot Trap in Agent Optimization A new Terminal-Bench 2.0 study shows most agent-optimization gains vanish the moment new tasks arrive, and only methods with regression control keep compounding over time. Here is what that means for anyone tuning agents in production.
- Bonsai 27B makes local agents smaller, not magically smarter PrismML’s ternary Qwen3.6 27B release is a real local AI milestone because it pushes a capable 27B-class model into laptop memory budgets. The catch is the same one builders keep relearning: compression saves RAM before it saves reliability.
- Memory Failures Hide Behind Correct Answers: What MemOps Exposes A new benchmark called MemOps stops scoring agent memory by final answers alone and starts tracing the operations underneath, revealing that a right answer can rest on stale, misbound, or inconsistent memory that standard evaluation quietly rewards.
- PalmClaw and the Case for Tool-First Mobile Agents A new open-source framework runs the whole agent loop on the phone and swaps screen-tapping for explicit device tools, claiming a 94.9% cut in task time. Here is what that design choice actually buys you and where it will hurt.
- Self-repair in small code models may be measuring retry form, not error content A placebo-controlled evaluation of small code models suggests some self-repair gains may come from retry structure, not the actual compiler error content, which should change how builders measure local coding agents. The useful question is not whether retries help, but why they help and when the error message truly matters.
- Useful work per dollar is the agent metric that matters OpenAI’s useful work per dollar frame is a better enterprise AI metric than token cost, but it only works if teams define outcomes, test agents against real workflows, and keep scaling decisions tied to measurable business work, not demos or vendor promises.
- Voice AI needs a human-quality test, not another pretty demo Hugging Face’s Real World VoiceEQ points at the right problem: voice AI is no longer just about clean audio, it is about timing, trust, interruption handling, and whether a system feels usable in messy human settings where demos usually hide the hard parts.
- Judge Bias Lives in the Activations, Not Just the Prompt A new mechanistic interpretability paper argues LLM-as-judge bias is a geometric structure in hidden states, not input-output noise, and that you can read it, steer it, and predict judge failures before they happen.
- What a Model Knows About What It Knows A new Yale-led survey maps metacognition in LLMs: how models track their own confidence, when they know they're wrong, and why that self-knowledge might matter more for reliable systems than another jump in raw capability.
- IoT exploit agents are getting useful in controlled labs VEXAIoT shows LLM agents chaining reconnaissance, vulnerability detection, and exploit execution against intentionally vulnerable IoT targets, with a 95% success rate in lab runs. The useful lesson is not autonomous hacking magic. It is where repeatable offensive workflows can become cheap enough to matter.
- Vision models are getting the scene right, but not always the gaze A new CSB benchmark suggests modern vision-language models can describe complex social scenes about as well as strong human annotators, but the remaining failures point less to vocabulary or hallucination and more to where the model chooses to look first.
- Intelligence Is Still Not the Product The AI 2040 framing points at a real trap: treating intelligence as the main variable. For builders, the harder problem is turning model capability into systems that work under cost, latency, trust, workflow, and organizational constraints.
- What Stampli's 'one person doing four people's work' claim actually shows A single vendor testimonial about scaling marketing content with ChatGPT hides a more useful lesson about connecting AI to your systems of record, and the quality tradeoff nobody in the video mentions.
- DiaLLM separates dialect understanding from dialect writing DiaLLM shows that models can read dialectal English better than they can write it, and that the tuning methods which score best on dialect rewards may still miss what human readers prefer.
- LangChain’s small July fixes point to bigger agent runtime problems LangChain 1.3.12 and langchain-openai 1.3.4 are small maintenance releases, but the fixes point at real production problems: retries that swallow interrupts, shell tools that kill too much, structured output warnings, async loop mistakes, and provider fallback state leaking across calls.
- GaP treats robot policies as editable graphs A new robotics paper points to a practical middle path between brittle hand-coded automation and opaque learned policies: agent-generated computation graphs that can be simulated, inspected, revised, and then run on real variational automation tasks.
- Verification as a Scaling Axis: What the LLM-as-a-Verifier Paper Actually Changes A new framework treats judging correctness as a compute dimension you can scale, not a fixed prompt. Here is what continuous scoring buys you, where the benchmark numbers hold up, and how a builder would wire it into an agent loop today.
- LangChain’s Mistral update is about provenance, not flash LangChain’s langchain-mistralai 1.1.6 release is small, but the useful parts are telling: citation metadata, stop sequence support, and package version tracing. That is not agent magic. It is the plumbing teams need before generated answers can survive audits, regressions, and real product constraints.
- LangChain’s OpenRouter header fix is a production clue LangChain’s OpenRouter 0.2.6 release is tiny, but default_headers support points at a real production need: carrying identity, routing, and observability metadata through model calls without rewriting client code or forking provider integrations every time the stack changes.
- MiniCPM5-1B points at the phone-sized agent layer The interesting part of MiniCPM5-1B is not that a tiny model can chat. It is that small models may finally be getting useful enough to act as local coordinators for tools, memory, and app-specific skills.
- The AI job diamond still needs a bottom rung IBM’s promotion metaphor is useful, but only if companies redesign entry-level work instead of quietly deleting it. The real shift is from doing isolated tasks to directing AI systems, reviewing outputs, and owning larger chunks of delivery sooner, with real training.
- The Model Got Smarter and My Tool Got Dumber As frontier models improve, the tools wrapped around them often get worse: more scaffolding, more prompt overhead, more guardrails fighting the very capability you paid for. A look at why that happens and how builders can avoid it.
- Speaker recognition is a better agent test than another chat demo DramaSR-532K turns long-form TV dialogue into a hard multimodal attribution problem, and the useful lesson is not that reasoning models are magic. It is that agents get interesting when they collect weak evidence across audio, faces, scripts, and scene context.
- Unlearning That Hides Instead of Erases: What LACUNA Exposes A new testbed injects synthetic PII into known model weights, then checks whether unlearning methods actually remove that knowledge or just paper over it. The answer, for most current methods, is uncomfortable.
- Safety evals need to test messy language, not just bad behavior A new adversarial pragmatics benchmark argues that many AI safety failures are really failures of linguistic judgment: instruction conflict, quotation, scope ambiguity, embedded commands, and evaluator disagreement hiding inside simple pass or fail labels.
- Anthropic’s Python SDK points to agents as infrastructure, not demos Anthropic’s latest Python SDK releases add claude-sonnet-5 support, but the more useful signal is managed-agent plumbing: streaming deltas, scoped credentials, overrides, pagination, and webhooks. That is the boring layer builders need before agent products can survive contact with production.
- PolicyGuard makes the compliance bot show its work PolicyGuard points at a better pattern for enterprise document review: let language models read messy clauses, but keep policy decisions in inspectable rules that teams can test, update, and challenge.
- The Cheap Way to Test Whether Your Agent's Step Scores Actually Mean Anything A new training-free benchmark called QVal checks whether dense supervision signals for long-horizon LLM agents actually order actions correctly, and the answer for most fancy methods is unflattering.
- TRIAGE gives agent RL a better target than pass or fail TRIAGE attacks a real training problem for agents: final-answer rewards blur which actions helped, wasted time, or made things worse. Its role-typed credit assignment looks like a practical step toward training agents that act with less flailing.
- Hugging Face model pages get a better eval paper trail Hugging Face is putting Every Eval Ever results directly on model pages, which makes model comparison less dependent on leaderboard screenshots. Useful, if builders treat the numbers as evidence to inspect rather than a single answer.
- World Models That Edit Their Own Context Instead of Their Weights A new framework called WorldEvolver gives LLM agents foresight by revising memory at deployment time while keeping every model parameter frozen. Here is what that design choice actually buys you, where it helps planning, and the catch builders should watch for before trusting predicted consequences.
- Agent immunity is the missing layer between alignment and tool use Agent security is moving from prompt filters and policy docs toward runtime defenses inside the agent loop, because memory, tools, and multi-agent protocols create attack surfaces that alignment alone does not cover. The ANIS proposal is useful as a map, even if the biology metaphor needs engineering proof.
- Google's Paper Assistant Wants to Catch Your Math Errors Before a Reviewer Does Google's Paper Assistant Tool catches mathematical and experimental errors in full manuscripts before submission, posting a 34% recall gain on a hard benchmark, and the real story is where it sits in the review pipeline, not whether it replaces reviewers.
- HORIZON treats chip design like a repo, not a chat prompt HORIZON’s hardware agent result is impressive because it reframes chip design as controlled repository evolution, with tests, traces, git state, and acceptance rules. The headline number matters less than the workflow shape, and the gap between benchmark success and real chip work is still large.
- Nash solvers have preferences when the value is identical A new Nash equilibrium study shows that solver choice can quietly pick different policies with the same game value, which matters when agents meet imperfect opponents in sequential, hidden-information settings. The lesson is practical: equilibrium is not always a single behavior, and algorithms have taste.
- Hermes Agent moves the agent demo into the payments layer Hermes Agent’s new Stripe and Nvidia integrations point to a practical shift: agents are no longer just chat loops, they are being wired into payments, servers, sandboxes, and product workflows, which makes permissioning and operational design more important than model theater.
- Hermes turns agent setup into packaging work Matthew Berman’s Hermes walkthrough shows a small but important shift in agent products: the hard part is no longer only model access or chat UI. It is packaging skills, hosting, credentials, and workflow defaults so a non-specialist can actually start using the system.
- Promptware Treats Prompt Injection Like an Execution Chain Promptware reframes prompt injection as an execution model, not a parlor trick, because agents collapse instructions and data into one token stream. The practical lesson is boring but urgent: isolate context, reduce tool permissions, and treat retrieved content like hostile input.
- What a one-line LangChain fix tells you about streaming reliability A small langchain-anthropic patch about keeping initial text on content_block_start is the kind of bug that silently eats characters in streaming apps, and it's a window into why agent UIs feel flaky even when the model is fine.
- Autodata Turns Synthetic Data Generation Into an Agent You Train A new method called Autodata treats data creation as an agent that can be meta-optimized, trading inference compute for higher quality training data, and the bigger gain comes from improving the data-maker itself rather than the data.
- Multimodal models still change answers when you shuffle the evidence Facet-Probe shows that frontier and open-weight multimodal models are not order-invariant, with answer flips across option order, evidence chunks, document rank, image sets, and mixed modalities. That is a reliability problem for builders, not just a benchmark footnote.
- Self-distillation can make models better on the first try and worse on the fifth A new arXiv paper argues that on-policy self-distillation can improve first-try accuracy while quietly collapsing the range of answers a model explores, which matters for agents, code generation, and any workflow that depends on multiple attempts to find a different path.
- Tool-use RL is failing at the brackets, not the tools A new arXiv paper shows agentic RL can break tool calling through tiny control-token failures, not lost capability, and that interleaving SFT helps. The catch is familiar: training for the format can stabilize agents while making them brittle outside the format.
- Codex record-and-replay turns screen demos into reusable skills OpenAI’s Codex record-and-replay feature points to a practical agent pattern: show the computer a task once, save it as a skill, then rerun it with new inputs for operations teams today. The useful version is narrow, auditable, and probably brittle at first.
- CUGA's Two Dozen Examples Are the Real Agent Documentation Hugging Face shipped CUGA, a lightweight agent harness with about two dozen working examples, and the examples matter more than the framework. Here is what builders should actually copy and where the thin claims still hide.
- Omio’s AI-native travel bet starts with messy trip planning OpenAI says Omio is using its models for conversational travel and faster product work. The interesting part is not a chatbot on top of booking, it is whether travel search, support, and itinerary changes can move from form-filling into a useful agent loop.
- The 4-second budget that decides if your AI agent ships Real-time marketing agents live or die by latency. Here's how I'm thinking about the sub-4-second budget when moving an LLM from demo to production, and which optimizations actually move the needle versus which ones just sound clever in a stand-up.
- Agent Success Rate is the only number that matters when a new model drops When a frontier model ships, vibes-based testing wastes the window. Here's how marketing operators can build an automated eval harness that turns 'feels smarter' into a measurable percentage jump on the workflows they actually ship.
- Marketers are still vibe-checking prompts. Frontier devs run evals before lunch. Frontier developers test new models with automated eval suites and track agent success rates as a percentage. Most marketers eyeball outputs and call it good. Here's how to port the eval mindset into a content or SEO workflow without a research team.
- Stop Vibe-Checking New Models. Build a 50-Prompt Eval Set Instead. Frontier developers run automated evals the moment a new model lands. Most marketers still open the chat window and eyeball the output. Here's how to close that gap with a simple benchmark set of past briefs, ad copy, and SEO tasks you can rerun in an afternoon.
- Splitting the agent loop from tool execution cut TTFT by 90% Anthropic's Managed Agents architecture separates reasoning from tool execution, which solves two problems marketing operators hit hard: securing API credentials for tools like HubSpot and WordPress, and the latency tax of spinning up containers per session.
- Agent Amnesia Has a Fix, and It Looks Like Sleep Claude's new Dreaming feature lets agents review their own logs between sessions and decide what to remember. For marketing operators fighting brand-voice drift and repeated mistakes in recurring workflows, this is the missing piece that turns one-off agents into ones that actually compound.
- Dreaming Agents Could Finally End the Brand Voice Correction Loop Anthropic's new Dreaming feature lets Claude review its own memory logs during downtime to decide what to keep. For marketing operators stuck retyping the same brand voice corrections, this is the first credible path to an AI editor that actually learns.
- How a 400-line system prompt becomes 15 lines with Skills A walkthrough of progressive disclosure as a fix for prompt bloat in marketing agents, why stuffing brand rules and SEO logic into one system prompt degrades reasoning, and how modular Skills restore eval scores while cutting token costs.
- The 200K Token CSV Problem Has a One-Line Fix Most marketing agents balloon past 200K tokens because operators dump entire CSVs into context. Giving the model a bash primitive to write and run Python against the file locally cuts cost, latency, and hallucination in one move.
- The 400-line system prompt is the new technical debt Marketing operators keep bolting business rules onto agent system prompts until performance collapses. Progressive disclosure through skills fixes the bloat, cuts token costs, and forces a cleaner architecture. Here is how the pattern actually works in practice and what most builders get wrong about when to use sub-agents.
- The mechanism matters: making AI competitive analysis auditable Single-shot prompts produce competitive analyses that look right but can't be trusted. The fix is treating the workflow itself as the artifact, with a logged, replayable trail of how the answer was built.
- Last Quarter Means Two Different Things Inside Your Own Company Marketing operators keep failing to ship working AI data agents because LLMs do not know what your company means by 'revenue,' 'last quarter,' or 'active user.' Here is the practitioner framework I am using to encode that context directly into the data, not the prompt.
- Split-brain agents: when planner and executor stop talking, quality collapses Multi-agent architectures look elegant on paper but break in subtle ways when the planning agent doesn't know what the execution agent can actually do. Consolidating tools into a single brain fixes a class of bugs that look like model randomness but aren't.
- The Frustration Index: A Cheap Eval Most Teams Skip A lean way to A/B test AI agents in production: pipe chat logs through a cheap LLM, classify user frustration per message, and use that single number to compare prompt, model, and infra changes without building a full eval suite.
- Why I Stopped Trusting Demo Videos for Agent Tools Agent demos look magical until you try to ship one. Here's what I've learned about the gap between a polished demo and a workflow that actually runs reliably on Monday morning when nobody's watching.
- When Your AI Agent Needs a Browser, Not an API Most agent failures come from assuming everything has a clean API. The real unlock for marketers is teaching agents to operate the same messy web tools we do, with the same hands a human would use.