Developers building AI Agents face a dilemma: Opus is smart but expensive, Sonnet is cheap but fumbles at critical moments. Anthropic's newly released 'Advisor Strategy' and Monitor tool turn this hard problem into a matter of one API parameter.

This article walks you through both features hands-on, from API calls to cost calculation, without skipping a step.

What Is the Advisor Strategy

The traditional approach is to make the strongest model the 'orchestrator', breaking big tasks into subtasks for smaller models. The problem: whether the task is simple or complex, every request starts by burning the most expensive tokens.

The Advisor Strategy flips it around: Sonnet/Haiku act as executors on the front line, and only when a hard problem shows up do they consult Opus. Opus never talks to humans directly and never calls tools; it only reads the context and offers advice.

Measured results:

Enable the Advisor Strategy with One Line of Code

Just declare advisor_20260301 in your Messages API request. The model handoff happens silently inside a single /v1/messages request -- no extra callbacks or context management needed.

response = client.messages.create(
    model="claude-sonnet-4-6",  # executor
    tools=[
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-opus-4-6",  # advisor
            "max_uses": 3,  # at most 3 consultations with Opus
        },
        # ... your other tools
    ],
    messages=[...]
)
# The tokens the advisor consumes are listed separately in usage

Key parameters:

• model: the executor model (Sonnet or Haiku)
• advisor_20260301: the advisor tool type, a fixed value
• advisor.model: the advisor model (usually Opus)
• max_uses: caps the number of advisor calls per request, preventing token overspend

How Token Costs Are Calculated

The tokens the advisor consumes are billed at Opus pricing; the tokens the executor consumes are billed at Sonnet or Haiku pricing.

The key point: each time the advisor weighs in, it generates only a short plan, usually 400 to 700 tokens. The bulk of the actual output is handled entirely by the executor at a much lower rate.

Which combination fits which scenario:

• Haiku + Opus advisor: high-concurrency, budget-sensitive scenarios, the lowest cost
• Sonnet + Opus advisor: the everyday choice balancing performance and cost
• Opus + Opus advisor: highest quality, for mission-critical tasks

Tip: Use max_uses to control how often the advisor is called. The advisor's token consumption is listed separately in the usage information, making it easy to track each model tier's spend.

The Monitor Tool: From Polling to Event-Driven

On the same day, Anthropic also launched the Monitor tool. It solves a different money-burning problem: Agents idling.

In the past, when you had an Agent watch a task (say, waiting for CI to finish), it had to loop and check constantly, burning a round of tokens with every check. Monitor lets Claude write its own background monitoring code, shifting from 'active polling' to 'event-driven'.

Typical uses:

• Watch system logs for errors continuously, and call the Agent in only when something is wrong
• Automatically track the status of a GitHub PR; a script polls in the background while the Agent burns no tokens
• Wake the Agent after an external event arrives (an email lands, a deploy finishes)

Monitor and the Advisor Strategy share the same logic: find the step that does not need to cost money and strip it out. One saves on model calls, the other saves on idle loops.

How to Wire It Up

Step 1: Confirm API Access

Make sure your Anthropic API account is active and has enough token quota. The Advisor Strategy is currently live on the Claude platform in beta.

Step 2: Modify Your Existing API Calls

In your existing Agent code, find the client.messages.create call and add the advisor tool configuration:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-opus-4-6",
            "max_uses": 3,
        },
        # your existing tool definitions...
    ],
    messages=[
        {"role": "user", "content": "Your task description"}
    ]
)

# Check the advisor's usage
print(response.usage)

Step 3: Monitor Costs

In the returned usage object, the advisor's and the executor's token consumption are tracked separately. You can use that to tune the max_uses parameter and find the balance between quality and cost.

Step 4 (Optional): Configure Monitor

For scenarios that need long-running monitoring, explicitly ask Claude in the prompt to create a background monitoring script instead of a polling loop.

FAQ

• Q: How is the Advisor Strategy different from ordinary model routing? A: Traditional routing makes you write the logic for when to switch models. The Advisor Strategy lets the executor decide on its own when to 'call for backup', and everything happens inside a single API request.

• Q: What is a good value for max_uses? A: 1-2 for simple tasks, 3-5 for complex programming tasks. Start with 3 and tune it based on the usage data.

• Q: Is the Advisor Strategy compatible with my existing tool stack? A: Fully compatible. The advisor is just an ordinary tool entry in the Messages API request; your Agent can search the web and execute code while consulting Opus.

References

• Anthropic official blog: https://claude.com/blog/claude-managed-agents
• Advisor Strategy API documentation: https://platform.claude.com/docs