Tool Calls or Structured Output? Two Mechanisms, Two Jobs

Both make a model emit JSON matching a schema. They look interchangeable in a tutorial, and choosing the wrong one produces awkward code that fights the mechanism for months.

The distinction is what happens next.

The difference in one line

A tool call is a request for something to happen and for the result to come back. The model expects a response and will continue reasoning with it.

Structured output is the model's answer, formatted. Nothing comes back. The turn is over.

Everything else follows from that.

When each fits

Use structured output when the model is producing the result. Classification, extraction, scoring, a decision with no follow-up. The schema constrains the shape of an answer.

classify_ticket(text) -> {category: enum, urgency: enum, needs_human: bool}

One call, one answer, done. Wrapping this as a tool means the model calls it, your code returns something meaningless like {ok: true}, and the model takes another turn to say what it already said. You've paid double and added a confusing turn to every trace.

Use tool calls when the model needs something it doesn't have, or must cause an effect. Fetching data, writing a record, running a computation. The defining feature is that the result changes what the model does next.

The confusing middle: "final answer" as a tool

A common pattern has the model emit its answer via a submit_answer(...) tool. It looks like structured output implemented as a tool call, and sometimes that's exactly right.

It earns its place when:

• The loop needs to distinguish "done" from "still working." A tool call is an unambiguous signal; text is not. This is the termination-signal problem, and a submission tool solves it cleanly.
• You want validation and a retry. The handler checks the answer and can return a violation for the model to fix, which structured output can't do mid-turn.
• Multiple answer shapes exist. submit_answer and report_blocked as two tools express a choice the model makes explicitly.

It's ceremony when the run is single-turn and there's nothing to validate. → Rule of thumb: if there's a loop, an answer tool helps; if it's one call, structured output is simpler.

Practical differences worth knowing

Parallel calls. Models can request several tool calls in one turn; structured output is one object. For fan-out, tools.

Schema enforcement. Both are typically constrained by the provider, but behavior on violation differs by API, and structured output modes often guarantee more. If you need a guarantee rather than a strong tendency, check what your provider promises for each.

Streaming. Structured output streams as a partial object, which is usable for progressive UI. A tool call's arguments also stream, but you generally can't act until complete.

The trace. Tool calls appear as discrete steps, which makes trajectory assertions natural. Structured output is just the response. ⚠️ If you want to assert "the agent submitted an answer with property X," a tool makes that easy; structured output means asserting on the final message shape.

Mixing them

Nothing stops you doing both, and the combination is often the cleanest design: tools for gathering, structured output for the final answer.

loop:
    reply = model(messages, tools=GATHER_TOOLS, response_format=ANSWER_SCHEMA)
    if reply.tool_calls: execute and continue
    else: reply is a validated ANSWER_SCHEMA object

The agent gathers with tools and, when it has enough, produces a schema-conforming answer rather than prose. You get validated structure without an extra turn and without a ceremonial submission tool. Support for this combination varies by provider, so check — but where it exists it's usually the right shape for a gathering agent with a structured deliverable.

✅ Choosing, in three questions

1. Does the model need something back? → Tool call.
2. Is this the end of the turn? → Structured output.
3. Is there a loop that needs to know when to stop, or validation with a retry? → An answer tool, otherwise structured output.

The takeaway

Tool calls are requests; structured output is an answer. Extraction, classification, and scoring want structured output — wrapping them as tools adds a turn and a fake result. Gathering and acting want tools. And when a gathering loop must produce a structured deliverable, combining both gives you validation without ceremony.