Claude Architect · 강의

tool_choice: auto / any / forced

모델에 선택을 맡기거나, 도구 사용을 강제하거나, 이름으로 하나를 지정합니다

tool_choice: auto / any / forced은(는) CoddyKit의 무료 Claude Architect 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Claude Architect 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Claude Architect 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Who Decides: Model or You?

When you give Claude tools, one question shapes the whole interaction: who decides whether a tool runs?

The tool_choice field on your API request answers it. You can let the model decide, force it to call some tool, or pin one specific tool by name.

Getting this right is core to Tool Allocation: the wrong setting produces chatty text when you needed structured data, or a forced tool call when the model should have just answered.

The Three Modes

There are three values for tool_choice:

auto — the model freely picks: emit text, or call a tool.
any — the model must call some tool (its choice which), so the turn returns a tool call, never free text.
{"type":"tool","name":"X"} — force one specific named tool.

Each maps to a different intent: flexible reasoning, guaranteed structured output, or a hard-pinned action.

request = {
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "tools": tools,
    "tool_choice": {"type": "auto"},  # or "any", or a named tool
    "messages": messages,
}

auto: Let the Model Choose

auto is the default mindset for agentic loops. The model inspects the conversation and decides on its own whether a tool is needed or a plain text reply suffices.

Use it when the path is open-ended: a support agent that might answer a question directly, or might need to look up an order first.

With auto, the stop reason tells you what happened: tool_use means run the tool and continue the loop; end_turn means the model answered in text and is done.

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "auto"},
    messages=messages,
)

if resp.stop_reason == "tool_use":
    # run the requested tool(s), append results, loop again
    ...
elif resp.stop_reason == "end_turn":
    # model replied with text; turn complete
    ...

any: Guarantee a Tool Call

any forces the model to call some tool every turn — it cannot reply with free-form prose. It still chooses which tool, but a tool call is guaranteed.

This is the classic lever for guaranteed structured output: if your only tool is a schema-shaped record_result, then any means every response comes back as validated JSON arguments, never an unparseable paragraph.

classify_tool = {
    "name": "record_sentiment",
    "description": "Record the sentiment of a customer message.",
    "input_schema": {
        "type": "object",
        "properties": {
            "sentiment": {"type": "string",
                          "enum": ["positive", "neutral", "negative"]}
        },
        "required": ["sentiment"],
    },
}

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=512,
    tools=[classify_tool],
    tool_choice={"type": "any"},  # must call a tool -> structured output
    messages=messages,
)

Forced: Pin One Tool by Name

The most specific mode forces exactly one tool: {"type":"tool","name":"X"}. The model has no choice about which tool — only how to fill its arguments.

Use it when the action is already decided and you just need the model to extract the parameters. Example: you know this turn must produce an extraction record, so you pin extract_invoice and let Claude fill the fields.

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=[extract_invoice_tool],
    tool_choice={"type": "tool", "name": "extract_invoice"},
    messages=[{"role": "user", "content": invoice_text}],
)

# resp.content[0] is a tool_use block with the extracted fields
fields = resp.content[0].input

any vs forced: The Subtle Line

Both any and forced guarantee a tool call. The difference is choice:

any — model still selects which tool from the set. Good when several tools are valid and you want structured output but flexible routing.
forced {"type":"tool","name":"X"} — no routing decision at all; tool X runs.

Rule of thumb: if you've already made the decision in code, force the tool. If the model should still decide which structured action fits, use any.

Structured Output Is the Big Win

Pairing a JSON-Schema tool with any or a forced tool is how architects get reliable structured output. The schema eliminates syntax errors and enforces required fields — no fragile regex on prose.

One schema rule matters here: mark a field required only if it is always present. Never require a field that may be absent — the model will fabricate a value to satisfy the schema.

extract_invoice_tool = {
    "name": "extract_invoice",
    "description": "Extract structured fields from an invoice document.",
    "input_schema": {
        "type": "object",
        "properties": {
            "invoice_number": {"type": "string"},
            "total": {"type": "number"},
            "due_date": {"type": "string"},  # may be absent -> NOT required
        },
        # only fields that are ALWAYS present belong here
        "required": ["invoice_number", "total"],
    },
}

auto Keeps the Agentic Loop Alive

In a multi-step agent, auto is usually right because the loop is model-driven. You send the full history each turn, read stop_reason, run any requested tools, append results, and repeat — until the model emits end_turn.

If you forced a tool on every turn, the model could never signal completion with text, and your loop would have no natural stop. Reserve forcing for single, decided actions.

while True:
    resp = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        tools=tools,
        tool_choice={"type": "auto"},
        messages=messages,
    )
    messages.append({"role": "assistant", "content": resp.content})
    if resp.stop_reason == "tool_use":
        results = run_tools(resp.content)
        messages.append({"role": "user", "content": results})
        continue
    break  # end_turn -> terminate on stop_reason, never on text

Don't Confuse Choice with Enforcement

tool_choice controls whether a tool is called — it does not enforce business rules. Forcing process_refund does not guarantee the refund is allowed.

Critical guarantees (identity verified, refund under the policy cap) belong in deterministic preconditions and hooks, which are 100% reliable, not in tool_choice or prompt text (~90% probabilistic).

Think of tool_choice as routing, and hooks/preconditions as guardrails.

Description Still Drives Selection

Even with auto or any, the model's tool pick depends on tool descriptions, not names. A good description states purpose, return values, input formats with examples, edge cases, and applicability boundaries.

Overlapping or vague descriptions cause misrouting that no tool_choice value can fix. Keep about 4-5 well-scoped tools per agent; 18+ degrades selection reliability.

tool_choice sets the policy; descriptions make the routing accurate.

A Practical Decision Guide

Pick by intent:

auto — open-ended agent turns; the model may answer in text or act. Default for the agentic loop.
any — you need structured output but several tools could apply; model routes among them.
forced (name) — the action is already decided; you only need argument extraction (classification, single-shot extraction).

If you've made the decision in code, force it. If the model should reason about whether and which, use auto or any.

# Single-shot classification: decision already made -> force it
resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=256,
    tools=[record_sentiment_tool],
    tool_choice={"type": "tool", "name": "record_sentiment"},
    messages=[{"role": "user", "content": review_text}],
)
sentiment = resp.content[0].input["sentiment"]

Quick Check

Choose the best tool_choice for the scenario below.

Recap: Choose, Guarantee, or Pin

Key takeaways:

auto — model picks text or a tool; the default for model-driven agentic loops that must be able to signal end_turn.
any — must call some tool; the lever for guaranteed structured output with flexible routing.
{"type":"tool","name":"X"} — pins one tool; use when the action is decided and you only need argument extraction.
tool_choice is routing, not enforcement — put critical guarantees in hooks/preconditions.
Accurate selection still depends on strong tool descriptions and 4-5 scoped tools per agent.

자주 묻는 질문

“tool_choice: auto / any / forced” 강의는 무료인가요?

네 — “tool_choice: auto / any / forced” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Claude Architect 강의 전체를 잠금 해제할 수 있습니다. Claude Architect 강의에는 총 4개의 강의가 포함되어 있습니다.

“tool_choice: auto / any / forced”에서 뭘 배우나요?

모델에 선택을 맡기거나, 도구 사용을 강제하거나, 이름으로 하나를 지정합니다 브라우저에서 직접 실행하는 실습 코드로 Claude Architect을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Claude Architect을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Claude Architect은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“tool_choice: auto / any / forced” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Claude Architect 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Claude Architect 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← Claude Architect(으)로 돌아가기