Debugging LLMs, web agents and the end of orchestrators

Today’s most important AI news

An applied-research Friday. The day was marked by three converging lines: new capabilities for understanding what happens inside models, a wave of papers on agents that operate on the web with more autonomy, and a result that should give pause to any team using LangGraph, CrewAI or similar today. There were no big product launches, but what came out today has direct implications for how software is built with AI.

Goodfire launches Silico: finally a tool to debug LLMs as if they were code

For years, training an LLM was like tuning a black box blindfolded: you tweak parameters, retrain, evaluate the output and pray. The startup Goodfire has just changed that dynamic with the launch of Silico, a mechanistic interpretability tool that lets you inspect the inside of a model and adjust its parameters at training time, not afterwards.

What Silico does is expose the model’s internal “features”, learned representations that correspond to specific concepts, and let engineers identify, understand and modify them surgically. According to Goodfire, this gives teams a level of control over model behavior that simply didn’t exist before. It’s not traditional fine-tuning: it’s intervening in the internal logic while the model is still being formed.

For developers and teams building products on their own or fine-tuned models, this opens a concrete possibility: instead of discovering problematic behavior in production and having to retrain from scratch, you could identify exactly which internal representation causes it and correct it. Mechanistic interpretability has stopped being an academic topic and is starting to have usable tools.

Web agents get more serious: real coverage, not random walks

Two papers published today attack the same bottleneck from different angles: agents that operate on the web are still unreliable because their training is deficient, and the benchmarks used to evaluate them don’t reflect reality.

AutoSurfer, presented on ArXiv, proposes a training-data generation system that overcomes the incomplete-coverage problem of current methods. The diagnosis is clear: when agents learn only from the homepage or by doing random walks through a site, they end up with a partial view of the web world and fail at tasks that require navigating real flows. AutoSurfer builds more complete and representative training trajectories, which translates into better accuracy on automation tasks.

InteractWeb-Bench complements this from the evaluation side. Its argument is that existing benchmarks assume idealized conditions: well-structured inputs, complete information, static execution. The real world is different: instructions are ambiguous, context is scarce and sites change dynamically. The benchmark proposes measuring agents under conditions closer to what they face in production. For a product manager or developer evaluating web automation tools today, this is a clear signal: the numbers you see on leaderboards probably overestimate these agents’ real performance on your use cases.

A well-written system prompt can replace LangGraph

This is the most provocative result of the day. An ArXiv paper presents a controlled comparison between agent orchestration architectures, such as LangGraph, CrewAI, Google ADK and OpenAI’s Agents SDK, and a simpler alternative: putting the entire procedure in the system prompt and letting the model orchestrate itself.

For procedural tasks, the simple architecture wins. Orchestration frameworks assume you need an external component that manages state and directs the model at each step. But when the task is well enough defined, the LLM itself can follow the flow without anyone holding its hand. The orchestrators’ overhead, in terms of latency, complexity and points of failure, isn’t justified in these cases.

The practical implication is direct: if you’re using LangGraph or CrewAI to automate a process with predictable steps, it’s worth running the experiment before assuming you need all that infrastructure. There are cases where multi-component agents make sense, especially for tasks that require real parallelism or coordination between specialists. But for procedural flows, the paper suggests the extra complexity is a cost without an equivalent benefit.

In a nutshell

Today’s pattern isn’t a big launch but something more interesting: maturity reaching layers that used to be opaque. Debugging a model as if it were code, evaluating agents under real rather than idealized conditions, questioning whether the frameworks everyone adopted actually add value — all of it points to an industry that’s starting to ask the questions you ask when a technology stops being a novelty and becomes infrastructure. The agent hype hasn’t disappeared, but the conversation has shifted toward reliability and control, which is exactly where it should be.

---

Sources used: https://www.technologyreview.com/2026/04/30/1136721/this-startups-new-mechanistic-interpretability-tool-lets-you-debug-llms/, https://arxiv.org/abs/2604.27253, https://arxiv.org/abs/2604.27419, https://arxiv.org/abs/2604.27891