LLM Structured Outputs for Reliable AI | Trilops

Structured outputs are model responses constrained to a predefined data shape. The shape is commonly expressed through JSON Schema or a language-native schema library such as Zod in TypeScript or Pydantic in Python.

JSON Schema is a declarative language for defining the structure and constraints of JSON data. A schema can specify that a field must be a string, integer, array, nested object, enum, or null. It can also require properties and reject unexpected keys.

“The patient probably takes 10 mg daily.
The record ID may be PT-183.
You should update the medication list.”

{
  "status": "requires_review",
  "patient_id": null,
  "dose_mg": 10,
  "frequency": "daily",
  "proposed_action": "none"
}

A schema can guarantee that a field is a string. It cannot guarantee that the string identifies a real patient. It can constrain a code to a pattern. It cannot prove that the code is supported by the source.

A schema should reflect what the application needs to decide next. It should not mirror the entire database or become a dumping ground for every possible explanation.

The example below uses Zod to define the contract and the OpenAI Responses API parser to request a schema-conforming result. Select and evaluate the model for the workflow rather than copying a model name blindly.

import OpenAI from "openai";
import { zodTextFormat } from "openai/helpers/zod";
import { z } from "zod";

const openai = new OpenAI();

const IntakeResult = z.object({
  status: z.enum(["supported", "uncertain", "blocked"]),
  patientName: z.string().nullable(),
  dateOfBirth: z.string().nullable(),
  requestedService: z.string().nullable(),
  missingFields: z.array(z.string()),
  requiresHumanReview: z.boolean(),
});

const response = await openai.responses.parse({
  model: "YOUR_EVALUATED_MODEL",
  input: [
    {
      role: "system",
      content: "Extract only stated information. Use null for missing values."
    },
    { role: "user", content: transcript },
  ],
  text: {
    format: zodTextFormat(IntakeResult, "intake_result"),
  },
});

const result = response.output_parsed;
if (!result) throw new Error("No parsed output was returned.");

The response is easier to consume, but the application still needs to validate it. Dates must be parsed. Patients must be matched through an approved identity workflow. Requested services must map to a valid catalog entry. Final actions must be authorized separately.

const validatedDate = result.dateOfBirth
  ? parseAndValidateDate(result.dateOfBirth)
  : null;

const service = result.requestedService
  ? await serviceCatalog.findApproved(result.requestedService)
  : null;

const canContinue =
  result.status === "supported" &&
  validatedDate !== null &&
  service !== null &&
  result.requiresHumanReview === false;

if (!canContinue) return routeToReviewQueue(result);

Function calling uses schemas to define the arguments a model can propose for a tool. Strict mode improves adherence to that schema. The application still decides whether the call is authorized and safe.

Once services, dashboards, queues, analytics jobs, and agent steps consume a structured output, the schema becomes an API contract. A small rename can break downstream systems or silently change decisions.

Schema conformance is a baseline metric, not the success metric. A system can achieve perfect parse success while returning the wrong entity, unsupported values, excessive nulls, or unusable results.

Authoritative references

• OpenAI API — Structured model outputs
• OpenAI API — Function calling and strict mode
• OpenAI API — Working with evals
• OpenAI API — Safety best practices
• JSON Schema — What is JSON Schema?
• JSON Schema — Specification

API capabilities and supported schema features change over time. Verify implementation details against the current documentation for the exact model, endpoint, SDK, and provider used by your application.