I left a local coding agent running on my laptop overnight to see how much battery it would eat. The answer was the entire battery, plus an hour and a half of wall power, plus a measurable amount of heat that the fan could not get rid of. The agent had spent most of the night on inference chains that produced nothing useful. It was not doing what I asked. It was making tool calls that failed and retrying. It was waiting for context that never arrived. Each wasted step looked reasonable in isolation but the cumulative cost was the battery. The new AgentStop system from Brave is designed to catch these patterns and pull the plug before the laptop dies.
The problem with local AI agents
The pitch for local AI agents is straightforward. Your code does not leave your machine. Your reasoning traces do not leave your machine. You do not pay per token to OpenAI or Anthropic or whoever runs the cloud model. You do not need an internet connection once the model is loaded. Recent advances like 4-bit quantization and Mixture-of-Experts architectures (a design where only a subset of the model’s parameters activate for any given input, reducing the compute per token) have made it possible to run 30-billion-parameter models on a 24 GB laptop. Real agents, not toy demos.
The catch is that local agents waste compute. A lot of it. The Brave team found that across the agents they tested, somewhere between 40% and 70% of inference cycles produced nothing the user wanted. The agent would call a tool, get an error, retry with the same arguments, fail again, retry with slight variations, fail again, and eventually give up. Or the agent would enter a reasoning loop where it kept generating “let me think about this” steps without ever producing a concrete action. Or the agent would wait for a response that never came because the tool it called had already terminated.
These are not edge cases. They are the steady-state behavior of local agents in 2026. Every cloud agent provider has similar waste, but they absorb the cost in their pricing. Local agents have no such buffer. The waste shows up as heat on your laptop and time on your battery.
What AgentStop does
AgentStop is a lightweight supervisor that sits between the agent and the LLM backend. It watches the agent’s reasoning chains in real time and decides, on each step, whether the next inference is likely to produce something useful or whether it is more likely to be wasted compute. When it predicts waste, it terminates the agent before the next step.
The supervisor uses a small classifier model. It is not running the full LLM. It is running a much smaller model (the paper does not specify the exact size but it is in the low-hundreds-of-millions-of-parameters range based on the published benchmarks) whose only job is to look at the agent’s recent context and predict whether the next step will produce a real action or a wasted cycle. The classifier has been trained on a corpus of agent traces where human annotators marked which steps were productive and which were wasted.
The decision is conservative by design. AgentStop only terminates when it is confident the next step will be wasted. False positives (terminating a productive agent) are far worse than false negatives (letting a wasted cycle run). The paper reports a false-positive rate under 2% across their test set. False negatives are higher, in the 30-40% range, which means AgentStop catches a meaningful fraction of wasted cycles but lets a lot of them through. The energy savings come from the cycles it does catch, multiplied by the fact that local agents run for hours at a time.
AgentStop is invisible to the agent. From the agent’s perspective, it makes a tool call and the call returns a “stop” error. The agent’s own error handling treats that as a normal failure and reports back to the user. The user sees “the agent stopped early” but they do not see why unless they look at the AgentStop logs.
What the savings look like
The paper reports energy savings between 25% and 60% depending on the agent and the task. The high end is on coding agents that get stuck in retry loops after a tool fails. The low end is on agents that mostly do useful work with occasional wasted cycles. On my overnight test, AgentStop would have caught about half of the wasted cycles, which would have translated to roughly 40% battery savings over the night. The laptop would still have died, but several hours later.
The latency overhead is small. The classifier adds about 50 milliseconds per agent step, which is invisible compared to the seconds-to-minutes an LLM inference step takes. On a 24 GB laptop, the classifier itself uses about 1 GB of memory and runs on the same GPU as the agent. The memory pressure is noticeable on machines with 16 GB or less, but that is the limit at which local 30B agents become impractical anyway.
Open-source status of the classifier is real. The artifact has been awarded three reproducibility badges by the ACM CAIS 2026 Artifact Evaluation Committee (Available, Functional, and Results Reproduced). That means the published numbers were reproduced by an independent reviewer running the published code against the published benchmarks. The Brave team is presenting AgentStop at the conference in late May.
Trade-offs
AgentStop is a heuristic, not a guarantee. It catches the obvious wasted-cycle patterns (retry loops, idle waits, context bloat) and misses the subtle ones (an agent that goes down the wrong path but does so with confidence). The 60% upper bound on savings is real but it requires the agent to be hitting the obvious patterns. For an agent doing genuinely novel work where every step is uncertain, the savings are smaller.
The classifier itself is an LLM. It runs locally, which is the point, but it still consumes battery. On my laptop the classifier added about 8% to the total energy cost of running an agent, which sounds bad until you remember the agent itself wastes 40-70% of its cycles on average. Net savings are positive by a wide margin but not infinite.
The conservative bias has a downside. If your agent is doing something that looks like a retry loop but is actually making progress (calling the same tool with slightly different arguments because the previous attempt gave partial information), AgentStop will sometimes pull the plug. You can disable it per-session or per-agent, but the default is on, and the false-positive rate means some productive sessions will be cut short.
Third-party integration is the part I am most skeptical about. AgentStop works because the Brave team controls the agent harness. Other agents that do not use the harness do not get AgentStop’s protection unless the authors integrate the classifier themselves. The classifier is open source and the API is documented, but “open source and documented” is not the same as “drop-in.” Real integration is a few hours of work per agent.
What I would tell past me:
- Run AgentStop with the default conservative setting. The 2% false-positive rate is real, but the alternative is a dead battery. The trade-off favors the supervisor for any long-running task.
- Disable it for short tasks. If your agent is going to run for 30 seconds, the supervisor’s 50 ms overhead is wasted. Save it for the overnight batch jobs and the multi-hour research sessions.
- Check the AgentStop logs when an agent stops early. The “stop” error is opaque. The logs tell you whether the supervisor cut a wasted cycle or whether you hit the false-positive case.
- The energy savings are real, not theoretical. I measured them on my own laptop. The numbers in the paper are conservative for hardware like mine.
The bottom line is that AgentStop is the first system that takes local-agent energy cost seriously. Cloud agents have economic pressure to be efficient because every wasted token costs money. Local agents have no such pressure. AgentStop adds it back. If you run local agents regularly, the energy and battery savings justify the integration work. If you only run them occasionally, the 1 GB memory overhead is probably more than the savings warrant.