Anthropic's new advisor tool cuts the cost of agentic Claude workloads, and we are all about that, so Frugal now supports it out of the box. Here's what it does, and why it flips the usual AI orchestration pattern on its head.

The conventional approach has a large, expensive model doing the reasoning and delegating subtasks to cheaper models. The advisor tool inverts this. A cheaper model (Sonnet or Haiku) runs the entire task end-to-end: calling tools, iterating on results, making decisions. When it encounters a problem it can't confidently resolve, it escalates to Opus. Opus receives the full context, returns a plan or correction, and the executor resumes. All within a single Messages API call. No extra round trips, no orchestration framework, just an additional tool in the request.

Why This Matters for Application Owners

The advisor pattern is genuinely useful, but not everywhere. It shines on agentic workloads where models are making decisions, calling tools, and iterating through multi-step tasks. It does nothing for a simple classification call or a single-turn JSON extraction.

That means application owners face two problems. First, they need to figure out which of their API calls are actually good candidates for the advisor. In a codebase with dozens of call sites, that's not obvious. Second, they need to make the code change at each of those sites: swap the model, add the advisor tool declaration, wire up the context passing.

Frugal handles both. We identify the high-value candidates across your codebase, estimate the savings for each one, and generate Frugal Fixes: pull requests with the exact code changes needed to enable the advisor where it'll actually pay off.

How Frugal Finds Advisor Candidates

Frugal scores every API call site using a combination of static code analysis and runtime signals.

On the source code side, we look for tool definitions in your API calls (strongest signal, since your executor will hit decision points), conversation history being accumulated across turns, high max_tokens values that suggest reasoning tasks, and system prompts with planning vocabulary like decide, iterate, or evaluate.

Frugal also adds instrumentation that gathers metrics at runtime and feeds them into our analysis. The clearest signal is stop_reason: "tool_use", meaning the model stopped mid-task to invoke a tool. We also look at tool call density (3+ per response means the model is navigating), output-to-input token ratios, session depth, and whether the call is currently running on Opus.

We filter out false positives too. Single-turn calls with no tools, fixed-schema extraction, simple persona prompts — those get ruled out automatically.

When a call pattern scores high on three or more signals without hitting a disqualifier, Frugal surfaces it as an advisor candidate.

Estimating the Savings

Frugal doesn't give you a single number and ask you to trust it. We use signals we're already gathering (your actual token counts, call frequencies, model selection, and task complexity) to build a savings estimate with the assumptions exposed.

Take a real example. Say Frugal observes a call site running 1,000 Opus calls per day, averaging 3,000 input tokens and 800 output tokens. We know your current daily spend on that call site is about $105. We model the advisor alternative with Sonnet handling the bulk work and Opus consulted on a percentage of calls, then factor in the advisor's typical token overhead.

The key variable is how often the executor escalates to the advisor. We present a range:

This call pattern is an advisor candidate. Based on observed token volumes and current pricing, we estimate 35-50% cost reduction at a 30-60% advisor invocation rate. The Frugal Fix below includes the code change to enable it.

You see the math. You see the assumptions. And the Frugal Fix gives you a PR with the exact changes (model swap, advisor tool declaration, context wiring) ready to review and merge.

Today, advisor optimization is available as a Custom Frugal Fix, and we're adding it as a standard Frugal Fix soon.

The Bigger Picture

The advisor tool is one example of a pattern we see constantly: cloud and AI providers release new pricing tiers, new APIs, new efficiency features. Most teams never find out about them, find out six months late, or simply don't go back and revisit working code just to apply a new option.

That's the core problem Frugal solves. It's not just about finding waste in what you're doing today. It's about keeping your applications current with the latest cost-reduction opportunities as they appear. The advisor tool launched yesterday. Frugal users are already seeing it surfaced as a Frugal Fix today.

New options for saving money ship all the time. Frugal makes sure you don't miss them.