Herramienta Claude Advisor: combine un ejecutor rápido con un planificador más inteligente

Tiene un agente de codificación ejecutando Sonnet. Maneja el 90% de los giros sin sudar: leer archivos, ejecutar pruebas, escribir texto estándar. Pero cuando se trata de una decisión arquitectónica complicada o de una concurrencia sutil error, desearías poder llamar a un amigo.

Esa es la herramienta de asesoramiento. La nueva función API beta de Anthropic permite un modelo de ejecutor más rápido (Sonnet o Haiku) Llame a un modelo de asesor de inteligencia superior (Opus) de media generación. El asesor lee la transcripción completa, produce un plan breve o corrección de rumbo, y el ejecutor continúa con la tarea. Una solicitud de API, Dos modelos, calidad cercana al Opus al precio de Sonnet.

Cómo funciona la herramienta Asesor

Cuando agrega la herramienta de asesoramiento a su tools matriz, el ejecutor decide cuándo llamarla, como cualquier otra herramienta. El flujo:

1. El ejecutor emite un server_tool_use bloquear con name: "advisor" Y una vacía input.
2. Anthropic ejecuta un pase de inferencia separado en el lado del servidor del modelo asesor, pasando la transcripción completa del ejecutor (indicador del sistema, definiciones de herramientas, todos los turnos y resultados anteriores).
3. La respuesta de la asesora vuelve como advisor_tool_result bloque (normalmente de 400 a 700 tokens de texto).
4. El ejecutor continúa generando, informado por los consejos.

Todo esto sucede dentro de un solo /v1/messages pedido. No hay viajes de ida y vuelta adicionales de tu lado. El asesor se ejecuta sin herramientas y sin gestión de contexto; sus bloques de pensamiento se eliminan y sólo el texto del aviso llega al ejecutor.

Su primera llamada de asesor: curl, Python y TypeScript

La herramienta de asesoramiento está en versión beta. Incluir el advisor-tool-2026-03-01 encabezado beta en sus solicitudes. Aquí está la llamada más simple posible:

rizo

curl https://api.anthropic.com/v1/messages \\
  --header "x-api-key: \$ANTHROPIC_API_KEY" \\
  --header "anthropic-version: 2023-06-01" \\
  --header "anthropic-beta: advisor-tool-2026-03-01" \\
  --header "content-type: application/json" \\
  --data '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 4096,
    "tools": [
      {
        "type": "advisor_20260301",
        "name": "advisor",
        "model": "claude-opus-4-6"
      }
    ],
    "messages": [{
      "role": "user",
      "content": "Build a concurrent worker pool in Go with graceful shutdown."
    }]
  }'

Pitón

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["advisor-tool-2026-03-01"],
    tools=[
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-opus-4-6",
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Build a concurrent worker pool in Go with graceful shutdown.",
        }
    ],
)

print(response)

Mecanografiada

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 4096,
  betas: ["advisor-tool-2026-03-01"],
  tools: [
    {
      type: "advisor_20260301",
      name: "advisor",
      model: "claude-opus-4-6",
    },
  ],
  messages: [
    {
      role: "user",
      content: "Build a concurrent worker pool in Go with graceful shutdown.",
    },
  ],
});

console.log(response);

Cómo se ve la respuesta

Una llamada de asesor exitosa produce cuatro bloques de contenido: el texto inicial del ejecutor, el server_tool_use bloque, el advisor_tool_result bloque, y el del ejecutor resultado final informado por el asesoramiento.

{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Let me consult the advisor on this."
    },
    {
      "type": "server_tool_use",
      "id": "srvtoolu_abc123",
      "name": "advisor",
      "input": {}
    },
    {
      "type": "advisor_tool_result",
      "tool_use_id": "srvtoolu_abc123",
      "content": {
        "type": "advisor_result",
        "text": "Use a channel-based coordination pattern. Close the input channel first, then wait on a WaitGroup..."
      }
    },
    {
      "type": "text",
      "text": "Here's the implementation using a channel-based coordination pattern..."
    }
  ]
}

La advisor_tool_result El contenido tiene dos variantes: advisor_result con texto plano consejo, y advisor_redacted_result con contenido cifrado. En ambos casos, ida y vuelta contenido palabra por palabra en turnos posteriores.

Pares de modelos válidos

El asesor debe ser al menos tan capaz como el ejecutor. Los pares no válidos devuelven un 400 error.

El punto óptimo para la mayoría de las cargas de trabajo: Sonnet como ejecutor, Opus como asesor. Obtienes un ascensor de calidad en Costo total similar o menor en comparación con ejecutar Opus para cada token.

Conversaciones de varios turnos

Pase el contenido completo del asistente, incluido advisor_tool_result bloques, volvamos a la API en turnos posteriores. Si omite la herramienta de asesoramiento de tools en un turno de seguimiento mientras el el historial de mensajes todavía contiene advisor_tool_result bloques, la API devuelve un 400.

import anthropic

client = anthropic.Anthropic()

tools = [
    {
        "type": "advisor_20260301",
        "name": "advisor",
        "model": "claude-opus-4-6",
    }
]

messages = [
    {
        "role": "user",
        "content": "Build a concurrent worker pool in Go with graceful shutdown.",
    }
]

# First turn: executor calls advisor, builds the worker pool
response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["advisor-tool-2026-03-01"],
    tools=tools,
    messages=messages,
)

# Pass back the full response content (including advisor_tool_result blocks)
messages.append({"role": "assistant", "content": response.content})
messages.append({"role": "user", "content": "Now add a max-in-flight limit of 10."})

# Second turn: executor has context from first advisor call
response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["advisor-tool-2026-03-01"],
    tools=tools,
    messages=messages,
)

Ingeniería rápida para agentes codificadores.

La herramienta de asesoramiento se envía con una descripción incorporada que empuja al ejecutor a llamarla cerca del inicio. de tareas complejas. Para cargas de trabajo de codificación y agentes, puede mejorar los resultados con un mensaje del sistema que refuerza dos tiempos:

• Una primera llamada temprana de asesor, después de algunas lecturas exploratorias en la transcripción
• Una llamada final al asesor después de que la escritura de archivos y los resultados de las pruebas estén en la transcripción

Este es el patrón de avisos del sistema que Anthropic recomienda para tareas de codificación. Produjo el mayor Inteligencia a un costo cercano al de Sonnet en evaluaciones internas:

You have access to an \`advisor\` tool backed by a stronger reviewer model.
It takes NO parameters. When you call advisor(), your entire conversation
history is automatically forwarded.

Call advisor BEFORE substantive work: before writing, before committing
to an interpretation, before building on an assumption.

Also call advisor:
- When you believe the task is complete (save your deliverable first)
- When stuck: errors recurring, approach not converging
- When considering a change of approach

The advisor should respond in under 100 words and use enumerated steps,
not explanations.

Combinando con otras herramientas

La herramienta de asesoramiento se compone de búsqueda web, ejecución de código y sus herramientas personalizadas en el mismo tools formación. El ejecutor puede buscar en la web, llamar al asesor y utilizar sus herramientas en el mismo turno. El plan del asesor puede informar qué herramientas utilizará el ejecutor a continuación.

tools = [
    {
        "type": "web_search_20250305",
        "name": "web_search",
        "max_uses": 5,
    },
    {
        "type": "advisor_20260301",
        "name": "advisor",
        "model": "claude-opus-4-6",
    },
    {
        "name": "run_bash",
        "description": "Run a bash command",
        "input_schema": {
            "type": "object",
            "properties": {"command": {"type": "string"}},
        },
    },
]

Almacenamiento en caché del mensaje del asesor

Hay disponibles dos capas de almacenamiento en caché independientes. El almacenamiento en caché del lado del ejecutor funciona igual que cualquier bloque de contenido: colocar un cache_control Punto de interrupción después de una advisor_tool_result y golpea.

El almacenamiento en caché del lado del asesor mantiene la transcripción del asesor almacenada en caché en todas las llamadas dentro de la misma conversación. Habilítelo con un caching campo en la definición de herramienta:

tools = [
    {
        "type": "advisor_20260301",
        "name": "advisor",
        "model": "claude-opus-4-6",
        "caching": {"type": "ephemeral", "ttl": "5m"},
    }
]

La escritura en caché cuesta más que las lecturas guardadas cuando se llama al asesor dos o menos veces. El almacenamiento en caché se equilibra con aproximadamente tres llamadas de asesor y mejora a partir de ahí. Habilítalo por mucho tiempo bucles de agentes; manténgalo apagado para tareas cortas.

Desglose de uso y facturación

Las llamadas de asesor se ejecutan como una subinferencia separada y se facturan según las tarifas del modelo de asesor. El usage.iterations array le ofrece un desglose por iteración:

{
  "usage": {
    "input_tokens": 412,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0,
    "output_tokens": 531,
    "iterations": [
      {
        "type": "message",
        "input_tokens": 412,
        "output_tokens": 89
      },
      {
        "type": "advisor_message",
        "model": "claude-opus-4-6",
        "input_tokens": 823,
        "output_tokens": 1612
      },
      {
        "type": "message",
        "input_tokens": 1348,
        "cache_read_input_tokens": 412,
        "output_tokens": 442
      }
    ]
  }
}

Nivel superior usage Los campos reflejan únicamente tokens de ejecutor. Iteraciones con type: "advisor_message" se facturan según las tarifas del modelo asesor. Utilice el iterations matriz al crear una lógica de seguimiento de costos.

Control de costes: limitación de llamadas de asesores

La herramienta de asesoría no tiene un límite de nivel de conversación incorporado. Usar max_uses en la herramienta definición de límites por solicitud. Para límites a nivel de conversación, cuente las llamadas del lado del cliente y Despoja al asesor cuando llegues a tu techo:

# Track advisor calls client-side
advisor_count = 0
MAX_ADVISOR_CALLS = 5

for turn in conversation:
    response = client.beta.messages.create(...)

    # Count advisor calls in response
    for block in response.content:
        if block.type == "server_tool_use" and block.name == "advisor":
            advisor_count += 1

    if advisor_count >= MAX_ADVISOR_CALLS:
        # Remove advisor tool and strip advisor_tool_result blocks
        tools = [t for t in tools if t.get("name") != "advisor"]
        for msg in messages:
            if msg["role"] == "assistant":
                msg["content"] = [
                    b for b in msg["content"]
                    if b.get("type") not in ("server_tool_use", "advisor_tool_result")
                    or b.get("name") != "advisor"
                ]

Manejo de errores

Si la llamada del asesor falla, el resultado lleva una advisor_tool_result_error con un error_code. El albacea ve el error y continúa sin consejo; la solicitud en sí mismo no falla.

Comportamiento de transmisión

La subinferencia del asesor no fluye. La transmisión del ejecutor se detiene mientras se ejecuta el asesor, entonces el completo advisor_tool_result llega en un solo content_block_start evento. Los keepalives de ping de SSE se activan cada 30 segundos durante la pausa. Planifique de 2 a 5 segundos de silencio por llamada del asesor, dependiendo de la duración de la transcripción.

Cuando la asesora ayuda (y cuando no)

Limitaciones para saber

• La salida del asesor no se transmite. Espere una pausa durante la subinferencia.
• No hay límite de nivel de conversación incorporado en las llamadas de asesores. Seguimiento y limitación del lado del cliente.
• max_tokens se aplica únicamente a la salida del ejecutor. No vincula los tokens de asesor.
• El nivel de prioridad del ejecutor no se extiende al asesor; Lo necesitas en ambos modelos.
• La función está en versión beta. Incluir anthropic-beta: advisor-tool-2026-03-01 en cada solicitud.