Pass a JSON schema in the format parameter of an Ollama chat request and the model's reply is forced to match that schema — that is ollama structured outputs in a single sentence, and it is the feature that turns a local model from a chatty toy into a component you can actually build automations on. Ollama's official announcement describes it as constraining "a model's output to a specific format defined by a JSON schema", giving you "more reliability and consistency than JSON mode". And it just got meaningfully better: the Ollama v0.34.4 release, published on 23 September 2026 on the project's official GitHub releases page, states that "structured outputs on thinking models now apply in a single pass, making them faster and more reliable".
📺 Watch: Run AI Agents Locally on Your Windows PC
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside · Want AI SEO help 1-on-1? Book a free SEO strategy session →
That one line is why this feature deserves a fresh look this week. Thinking models — the ones that reason before answering — used to be the awkward case for constrained output. With the single-pass change, the newest local reasoning models and schema-enforced JSON now play properly together, which matters for anyone running agents against local models the way the funnel's Ollama plus Hermes guide lays out.
How Ollama structured outputs work
The mechanism is simple to hold in your head. A normal chat request sends messages and gets prose back. With structured outputs, you also send a format parameter containing a JSON schema — an object type, the properties you want (say a country name, its capital and a list of languages), and which of those properties are required. The model's response is then constrained to valid JSON matching that schema, rather than JSON-ish text you have to clean up afterwards.
Ollama's documentation recommends not hand-writing those schemas at all. In Python you define a Pydantic class and pass its model_json_schema output as the format value, then parse the reply back through model_validate_json — so the same class defines the contract and validates the result. In JavaScript the equivalent flow uses a Zod schema converted with zodToJsonSchema, parsed back with the schema's own parse method. Ollama's official tips for reliable results are worth quoting directly: use Pydantic or Zod to define the schema, add "return as JSON" to your prompt, and "set the temperature to 0 for more deterministic output".
The use cases Ollama's announcement names are exactly the ones automation builders care about: parsing data from documents, extracting data from images with vision models, and structuring every language-model response so downstream code never has to guess. If a step in your workflow feeds another program rather than a human, that step should be running structured outputs.
If you want working local-AI pipelines instead of weekend experiments — schemas, agents and money-making workflows already built — the AI Profit Boardroom includes the full Agent OS zip, prompt libraries and weekly live coaching calls → grab the working systems inside. Want a personal plan first? Book a free SEO strategy session and map your build with Julian.
What changed for Ollama structured outputs in v0.34.4
The fresh news, straight from the official release notes of 23 September 2026: on thinking models, structured outputs now apply in a single pass. Previously, combining a reasoning model with a strict output schema was the slow path; the single-pass change makes it both quicker and more dependable, in the project's own words "faster and more reliable". The same release also notes that "Qwen 3.8 prompt processing is faster on Apple Silicon" and that Gemma 4 on Apple Silicon "now picks the best image resolution per image" — two lines that matter if your extraction pipeline feeds images through a local vision model on a Mac.
Its sibling release, v0.34.3 of 19 September 2026, adds a supporting piece: the show endpoint of the Ollama API "now advertises thinking levels and defaults" for thinking models. Practically, your code can now ask a model what reasoning levels it supports before deciding how to call it — useful when the same pipeline runs against several local models and needs to adapt per model rather than hard-coding assumptions.
Put those together and the direction is clear: Ollama is making reasoning models first-class citizens for programmatic use. Schema enforcement in one pass, discoverable thinking controls, faster prompt processing on consumer hardware — that is the plumbing you need before you trust a local model inside a revenue workflow.
Why structured outputs matter for local AI automations
Anyone who has built on raw model output knows the failure mode: the model answers brilliantly, wrapped in three sentences of pleasantries that break your parser. Multiply that by a few hundred runs a day and unstructured output is the single biggest source of silent breakage in local AI automation. Schema enforcement removes the whole failure class — the response either matches your schema or the call fails loudly, and loud failures are fixable failures. There is a cost angle too: every malformed response you have to detect, retry or repair is wasted compute and wasted time, and on a local machine that waste comes straight out of your own hardware budget rather than an API bill you can shrug at.
Structured outputs also change which models are good enough. A mid-sized local model that reliably fills a simple schema beats a bigger, cleverer model that free-styles its formatting, because the automation around it never breaks. That reshuffles the usual rankings — the funnel's guide to the best Ollama model for Hermes Agent covers which local brains hold up in agent work, and the wider best Hermes agent LLM comparison covers the trade-offs when you widen the choice beyond local. For the hands-on numbers on how these model brains compare, the Goldie Bench write-up is the reference point.
And this is very much an agent story, not just a scripting story. An agent that researches, extracts and files data is only as reliable as its least reliable hand-off, and every hand-off between steps is a place where schema-enforced JSON keeps the chain intact. If you are building towards that, setting up Hermes with Ollama is the natural next step once you have structured outputs working — the agent layer inherits all the reliability you build at the model layer.
Getting started: a practical sequence
- Update Ollama to v0.34.4 or later — you want the single-pass behaviour on thinking models before you benchmark anything, and the release is current as of 23 September 2026.
- Define your schema in Pydantic or Zod — per Ollama's own tips, generate the JSON schema from a typed class rather than writing it by hand, so validation comes free.
- Say it in the prompt too — Ollama recommends telling the model to return JSON in the prompt itself, alongside the format parameter, and dropping temperature to 0 for deterministic output.
- Pick your model deliberately — smaller models that fill schemas reliably beat larger ones that do not; test a shortlist against your real schema before committing. Pipelines that pair a local extractor with a heavyweight reasoning model — the pattern covered in the Hermes and DeepSeek write-up — put the schema on the extraction side.
- Wire it into your agent — once single calls are reliable, move the schema-enforced steps into your agent workflow so every machine-to-machine hand-off is typed.
Ollama structured outputs FAQ
Is this different from JSON mode?
Yes, and the difference is the point: JSON mode promises valid JSON, while structured outputs promise valid JSON that matches your schema. Ollama's announcement is explicit that schema constraint offers "more reliability and consistency than JSON mode".
Does it work with vision models?
Extracting data from images is one of the use cases Ollama's announcement names directly, and the v0.34.4 notes add that Gemma 4 on Apple Silicon now picks the best image resolution per image — so image-to-schema extraction on local hardware is an intended, actively improved path.
Which endpoint takes the format parameter?
The chat API accepts the format parameter carrying your JSON schema, and the official Python and JavaScript libraries expose the same option — with Pydantic and Zod as the recommended way to generate the schema you pass.
Do I still need this if my model is very smart?
Yes. Formatting discipline and intelligence are different axes, and automations break on formatting. The best Hermes agent models round-up makes the same point from the agent side: reliability under repetition is what separates production picks from demo picks. It is also core to how the Agent OS approach structures agent work — typed hand-offs between steps, so no step depends on another step's prose.
If you want to turn local models into systems that actually pay for themselves — extraction pipelines, SEO automations and agents running on your own hardware — check out the AI Profit Boardroom → start building inside. Rather talk it through first? Book a free SEO strategy session and get a straight plan for your stack.
