Match each structured output toolkit to how it enforces the schema

Match pairs·Medium·4.0 · 0·~2 min·Asked atRedis Sourcegraph Workday

Attempt it

Drag each answer to line up with its matching prompt

OpenAI Structured Outputs

Pydantic model + retry and repair loop on the client side; works across providers

Anthropic tool use with input_schema

Server side JSON mode with a schema field on the generation config

Instructor (Python)

Zod schema enforced by the SDK with retries; framework agnostic on the server

Vercel AI SDK generateObject

Server side constrained decoding bound to a JSON Schema; invalid output is impossible by construction

Outlines / SGLang grammar

Tool definition includes a JSON Schema the model is biased to match; library validates on receive

Google Gemini responseSchema

Local constrained decoding via regex or context free grammar at the token level

Structured-output toolkits all promise the same thing: you get back JSON that matches a shape you defined. How they keep that promise splits into three camps. The **server-side constrained decoding** camp lives at the provider. OpenAI Structured Outputs in strict JSON Schema mode and Outlines for self-hosted models both mask the sampler's logits so the model literally cannot emit a token that would leave the grammar. The output is schema-valid by construction. The **server-side bias** camp also lives at the provider but is softer. Google Gemini responseSchema and Anthropic tool use input_schema bias the model's distribution toward the schema and validate at the boundary. Most outputs match; the rare miss is caught by the SDK. The **client-side validate-retry** camp lives in your application code. Instructor for Python and the Vercel AI SDK generateObject for TypeScript take a Pydantic or Zod schema, run the call, parse the response, and on validation failure retry with the error message included in the next prompt. Works across any provider because it does not depend on provider-specific enforcement. The trade is reliability versus portability. Server-side constrained decoding is tightest but ties you to one provider's feature; client-side validate-retry is most portable but pays retry latency on edge cases.

The six toolkits in this question are not interchangeable. They sit on a spectrum of how aggressively the schema is enforced and where in the stack the enforcement happens. ### The three server-side stacks **OpenAI Structured Outputs** in strict mode compiles your JSON Schema (often generated from a Pydantic model) into a token-level grammar and masks logits at every decode step. Invalid output is impossible. This is the strongest guarantee on a closed-API provider. **Anthropic Claude tool use** ships an `input_schema` with each tool definition. The model is biased to match the schema during generation and the API server validates the tool argument before returning it. Slightly looser than OpenAI strict mode but the validation step is still server-side. **Google Gemini responseSchema** lives on the generation config object. Gemini 3.1 Pro respects the schema as a structured-output mode; the enforcement is closer to a strong JSON mode plus shape validation than to OpenAI's full constrained decoding, but the practical reliability is similar in 2026. ### The three client-side stacks **Instructor (Python)** takes a `response_model: BaseModel` argument, runs the underlying provider call, parses with Pydantic, and on `ValidationError` retries the call with the error appended. Cross-provider, works against OpenAI, Anthropic, Gemini, and self-hosted models. **Vercel AI SDK generateObject** is the TypeScript counterpart. Pass a Zod schema, get a typed object back. Same validate-retry loop, packaged for Next.js and Node servers. **Outlines / SGLang** is a different animal: a local constrained-decoding library for self-hosted models. It compiles a regex or context-free grammar to a sampler mask and ships with vLLM and SGLang integrations. The only entry on this list that gives you grammar-level (not just JSON-shape) constraints on open-weight stacks. ### How to pick - One closed provider, max reliability → OpenAI Structured Outputs. - Multiple closed providers,

TL;DR

Three toolkits enforce schema on the server (OpenAI, Anthropic, Gemini), three on the client (Instructor, Vercel AI SDK, Outlines self-hosted); Outlines is the only true grammar-level constraint.

Memory aid

Easy to grasp

Imagine six checkout lines in a grocery store. Three of them have a real machine that physically refuses to scan an item that is not on your list, so you cannot leave with the wrong thing. Three of them have a kind cashier who looks at your bag at the end, and if something is wrong, sends you back to fix it. Both keep your bag correct, but the machine catches the error before it happens and the cashier catches it after. Some lines are at the store you visit (server-side); some lines are at a check station in your kitchen at home (client-side). Different stores have different machines, and one of them, Outlines, has a special scanner that checks the shape of every single item, not just the bag at the end.

Key concepts

Context engineering LLM frameworks Prompt engineering

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

On a feature-comparison page these six toolkits look like the same thing with different vendor logos. They all take a schema, they all return structured JSON, they all 'enforce' it. Pick whichever fits your stack.

In production they fail differently and that is where the choice gets interesting. A team that picks the wrong one is not breaking on the happy path. They are breaking on the edges: a tail input where the schema-invalid output costs a tool call retry; a schema compile that adds 200ms to p99; a cross-provider deployment where one of the providers does not honor the schema as strictly as the other.

The right way to read this matrix is by enforcement layer, not by vendor. There are three layers, server-side constrained decoding, server-side bias plus validation, and client-side validate and retry, and each layer has a different failure profile. Once you know the layer, the vendor choice is mostly about which provider your stack is already on.

Server-side constrained decoding (OpenAI, Outlines)

This is the hardest guarantee available. The provider takes your JSON Schema, compiles it to a finite-state grammar over the tokenizer's vocabulary, and masks the sampler's logits at every decode step. Any next-token that would leave the grammar gets a logit of negative infinity. The output literally cannot leave the grammar.

OpenAI Structured Outputs in strict mode (response_format=json_schema) gives this guarantee for GPT-5.5 and the 4.1-class snapshots. The Pydantic to Schema compile happens in the SDK, the Schema to grammar compile happens on the server, and the grammar is cached by schema hash so subsequent calls do not pay the compile cost.

Outlines and lm format enforcer give the same guarantee for self-hosted models via vLLM, SGLang, or Transformers backends. SGLang 0.4's structured generation pipeline fuses grammar compilation into the prefill kernel, which removes the per-call compile overhead almost entirely.

The failure mode this layer cannot escape is forced fills. When the input does not contain enough information to satisfy a required field, the sampler picks something rather than fail. You get a well-shaped output with priority: 'medium' because the grammar required a priority value. The fix is to mark fields optional in the schema rather than hoping the model will refuse to fill them.

Server-side bias plus validation (Anthropic, Gemini)

Client-side validate and retry (Instructor, Vercel AI SDK)

Picking the right toolkit

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Toolkit	Layer	Enforcement	Best for
OpenAI Structured Outputs	Server	Constrained decoding (hard)	Closed-provider strict extraction
Anthropic input_schema	Server	Biased + validated (medium)	Claude tool calls in agents
Gemini responseSchema	Server	Biased + validated (medium)	Gemini-native structured tasks
Instructor (Python)	Client	Validate + retry (soft)	Cross-provider Python agents
Vercel AI SDK	Client	Validate + retry (soft)	Next.js / Node TypeScript apps
Outlines / SGLang	Server (self-hosted)	Token-level grammar (hard)	Self-hosted open-weight models

Real products, models, and research that use this idea.

OpenAI Structured Outputs in strict mode ships with the GPT-5.5 responses API; the Python SDK's responses.parse method accepts a Pydantic model directly.
Anthropic Claude Opus 4.7 tool use enforces input_schema on every tool argument; the same mechanism powers Computer Use and the MCP tool layer.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow does Outlines compile a Pydantic model into a token-level mask, and why is that compile step expensive?

Pydantic compiles to JSON Schema, the JSON Schema compiles to a regex or context-free grammar, the grammar is converted to a deterministic finite automaton over the tokenizer's vocabulary. The DFA construction is O(|grammar| x |vocab|) and is the slow step; cache by schema hash.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Treating these six as the same feature with different vendor logos. They split into server-side constrained decoding, server-side bias, and client-side validate-retry, each fails differently.

60 second bullets to scan on the way to the call.

Which three toolkits enforce on the server side
Which three toolkits enforce on the client side

Primary sources. Browse if you want the original framing.