Structured Output

Why it matters

Most of the time you ask a question, you want an answer in plain prose — explained, argued, talked through. But sometimes prose is exactly the wrong shape. You have a pile of content that already exists — a draft itinerary, a list of expenses, a set of quarterly goals — and what you actually need is for it to be rendered into a specific form: a table with these columns, a one-page status report, a tournament bracket, a memo in this layout. The value is not in new thinking; it is in the content arriving in the shape you can use, with every required slot filled and nothing extra bolted on. Structured Output is the discipline of fitting existing content to a specified contract — a schema, a template, a fixed set of fields — exactly, and refusing to invent the parts that are missing.

For example: you paste in nine lines of an expense log and ask for a one-page report with columns for date, vendor, category, amount, and notes. You do not want the entries summarized, re-categorized, or “cleaned up.” You want each line dropped into the right cells, the column order honored, the total format consistent — and if one entry is missing its category, you want that gap flagged, not silently filled with a plausible guess. The work is faithfulness to a shape, not commentary on the contents.

What it produces. Your existing content rendered into the exact structure you named — a table, schema, outline, memo, bracket, or fixed-field document — consistent, drop-in usable, and often machine-readable rather than something you have to re-key by hand.
How it changes the work. The question stops being “what should I say about this?” and becomes “does every required field have its value, is the shape honored exactly, and is anything here that the contract did not ask for?” — rendering, not authoring.
When to reach for it. You already have the content and you can name the target format precisely; the task is presentation, not analysis — and you want the result to match a contract closely enough to paste straight into a doc, a sheet, or another system.
What you’d miss without it. Hand-rendering is where silent errors creep in — a dropped row, an invented value, a column reordered, an entry quietly “improved.” A disciplined rendering keeps the content yours and surfaces the gaps instead of papering over them.
Where it misleads. Its one real temptation is to compensate for missing input — to manufacture a plausible-looking value for a field the source never supplied, which you might then mistake for your own data. Honored properly, the mode flags the gap and asks; pushed to “just fill it in,” it fabricates.

How to invoke it in Ora

You already have the content and you want it rendered into a specific form — faithfully, without it being edited, summarized, or improved along the way.

Supply the content and name the format and ask:

“Structured output — format this into a one-page report with columns for [date, vendor, category, amount, notes]. Faithful rendering of what I’ve drafted, no edits.”

The phrases structured output, format this as, render into, one-pager / table / bracket with columns for, and faithful rendering of what I’ve drafted are what route you here. Bring two things and the rendering is clean: the source content itself, as completely as you have it (the actual entries, items, or data — not a description of them), and the target format named precisely — which columns, which fields, which layout, how many slots. The more exactly you name the shape, the less the mode has to infer.

One thing worth knowing up front. The mode will not fabricate values to fill a field your source did not supply — when it hits a missing field, an entry that does not fit the format, or an unclear ordering, it flags the gap rather than inventing a resolution. That refusal is the feature: fill the gap, supply the missing field, or accept that the rendering shows the gap honestly. The alternative is content that looks like yours but is the mode’s invention.

How it works

The simplest way to see the mode is to watch it turn a paragraph into a table. Suppose you hand it a few sentences of notes — “03/04 Acme Office $124.50, supplies, printer toner; 03/12 Delta $487, travel, NYC client visit; 03/18 Slack $99, software, annual seat” — and ask for a report with columns for date, vendor, category, amount, and notes. The mode’s job is not to think about your spending. It is to read the contract — five named columns, in that order — and pour your content into it: 03/04 into date, Acme Office into vendor, supplies into category, $124.50 into amount, printer toner into notes, then the next line, then the next. The output is a clean five-column table where every row is your content and the shape is exactly what you asked for. Nothing was added; nothing was interpreted; the value is that you can paste it straight into a spreadsheet.

That is the heart of it: Structured Output is an operating mode, not an analytical one. The other modes reason — they trace a cause, weigh a decision, map a structure, and the answer they give back is new. This mode renders. It produces its result in a specified structure — a schema, a template, a table, a fixed set of fields, sometimes literal JSON — rather than in free prose, so the result is consistent, machine-readable, or drop-in usable by whatever comes next. The discipline is fitting the content to the contract: every required field filled, the shape honored exactly, and nothing extraneous carried along. A good rendering is one where, if you compare it back to your source, you find all of your content and none of the mode’s.

Two disciplines hold the rendering honest, and they pull against each other in a way worth understanding. The first is faithfulness: the content is yours, so the rendering must not silently summarize, edit, re-order, or “improve” it. If your notes say “printer toner,” the cell says “printer toner” — not “office supplies (toner).” The mode is rendering what you wrote, not paraphrasing it. The second is refusing to fill what is missing. A format demands fields; your source may not supply all of them. The lazy move — and the one failure that quietly corrupts everything — is to invent a plausible value for the empty field: a guessed category, a made-up date, a placeholder that reads like real data. You might paste that into a report and never notice it was fabricated. So the mode does the opposite. When the contract needs a field the source did not provide, when an entry will not fit the format, or when the ordering is genuinely unclear, it stops and flags the gap rather than imposing a resolution you never chose. There is one narrow exception that is not a violation: aligning to the format’s own conventions — consistent capitalization within a column, a standard date format, padding a bracket to the next power of two — is part of rendering, and when the mode makes such an adjustment it says so.

The boundary that defines the mode is the line between rendering and authoring. If the content already exists and the work is shaping it, this mode is right. If the content has to be produced — original analysis, a real comparison the system must actually perform, a deliverable that requires new thinking — that is authoring work, and it belongs upstream before any rendering happens. The honest tell is the missing field: if a gap turns out to need a guessed value, that is not a rendering question at all. It is a signal that real content is missing, and the right response is to go get it, not to manufacture it. Structured Output earns its keep by being excellent at exactly one thing — putting content you already have into the shape you can use — and by being unwilling to drift into making the content up.

Framework & implementation

This section uses Ora’s own terms for the parts of an analysis, so that if you open the actual mode file they line up. Each is glossed in plain language on first use.

Pipeline execution

Structured Output is the rendering-only mode in the execution / project-mode territory — the operating mode Ora invokes when content already exists and the task is faithful rendering into a named format, not original work. It sits beside its sibling Project Mode, the original-execution mode: where Project Mode thinks (the deliverable requires content the system must produce), Structured Output renders (the content is supplied; the job is the shape). Because the work is presentational rather than adversarial, it runs a single rendering pass rather than the depth-and-breadth analytical cascade the reasoning modes use.

The pass does three things in order. It locks the source and the contract — the supplied content on one side, and on the other the requested format with its conventions made explicit: column structure, headers, hierarchy, ordering, field set. The format is the operative deliverable; everything downstream commits to it. It renders faithfully — pouring the content into the contract without summarizing, editing, augmenting, or re-ordering it, since the content is the user’s and the rendering’s only job is the shape. And it surfaces ambiguities — when the source lacks a field the format requires, holds an entry the format has no slot for, or has an ordering the rendering cannot resolve, the mode flags the issue rather than imposing a resolution the user did not choose. The load-bearing discipline across all three is the refusal to compensate for missing input: the mode will not generate content to fill format-required fields the source did not supply.

When the requested format is itself analytical — a comparison table that requires the comparison to actually be performed, say — the mode recognizes that the substantive work is upstream and routes to the relevant analytical mode first, then renders that mode’s output into the format. The routing default runs the safe direction: because Project Mode can render but Structured Output must never originate, an ambiguous “render-or-author” request resolves toward Project Mode.

Output contract

The deliverable is whatever structure the user named — and that is the contract. A table arrives with exactly the requested columns, in the requested order, every row drawn from the source. A status report or one-pager arrives with its fixed fields populated and nothing extra. A bracket arrives with the seeded structure honored. Where the source under-supplies the contract, the gap is shown explicitly — an empty cell, a flagged field, a stated ambiguity — never a fabricated value dressed as data. Where the mode applies a format convention (consistent capitalization, standard date formatting, structural padding), it names the adjustment rather than making it silently. The test the contract has to pass: compare the output back to the source and you find all of the user’s content, none of the mode’s invention, and the shape exactly as specified.

Origin and evidence

The mode has no single founding text, because it formalizes a discipline that runs through several traditions of getting content into a fixed shape without distorting it. From technical and editorial style comes the core posture: Strunk and White’s The Elements of Style (1959) is the canonical statement of fitting content to a fixed set of conventions and rendering it without embellishment — the prose-craft ancestor of “honor the contract, add nothing extraneous.” From data modeling comes the idea that a structure is a contract the content must satisfy: David Hay’s Data Model Patterns (1995) treats schemas as agreed shapes that data is obliged to fit, which is exactly the relationship between a requested format and the content rendered into it — and is where the discipline’s machine-readable edge (a schema, a fixed field set, JSON) comes from. The modern lineage runs on to information design and document templating, where the same rule holds: the format is given, the content fills it faithfully, and inventing data to satisfy a field is a defect, not a convenience.

Applications and common uses

Reports and one-pagers. The native use: an expense log, status report, or quarterly-goals list rendered into a fixed-column, single-page layout that drops straight into a doc.
Meeting and planning artifacts. A draft recap rendered into a one-page agenda with columns for time, topic, owner, and decision-needed — the content already drafted, the shape applied.
Brackets, schedules, and matrices. A seeding list rendered into a single-elimination bracket, a draft into a schedule grid, options into a decision matrix — structures with strict conventions the rendering must honor.
Machine-readable extraction. Loose notes or prose rendered into a table, schema, or JSON object with a fixed field set, so the result can be consumed by a spreadsheet or another system rather than re-keyed.
Downstream of analysis. When an analytical or synthetic mode has produced content the user wants in a particular presentational form, Structured Output renders the result — the common last step after the thinking is done.

Failure modes and when not to use it

Fabricating to fill a field. The defining failure: generating plausible-looking content for a format-required field the source never supplied, which the user may accept as their own. The mode’s entire discipline is to flag the gap and ask rather than invent.
Silent improvement. Summarizing, re-categorizing, re-ordering, or “cleaning up” the content while rendering it — a subtler form of fabrication, since it returns something that is no longer purely the user’s. Faithfulness forbids it; genuine convention-alignment is the only permitted adjustment, and it is named, not silent.
Format drift. Reordering columns, renaming fields, or quietly changing the requested structure because a different shape seemed better. The requested format is treated as given; redesigning it is a different task.

When not to reach for it. When the content does not yet exist and original work is needed to produce the deliverable, route to Project Mode — Structured Output renders, it does not author. When the request needs substantive analysis (a comparison that must actually be performed, a deliverable that requires new thinking), the analytical work is upstream; do it first, then render. When you want the content itself critiqued, edited, or improved, that is a review or analytical task, not a faithful rendering. And when the real question is how to design the format rather than how to apply one, that is format engineering — this mode treats the requested format as a given.

Project Mode — the original-execution sibling in the same territory and the safe default when “render or author” is ambiguous: where this mode renders content that already exists, Project Mode produces content that does not, surfacing the build decisions it makes on your behalf.
Comparison Chart — the mode to run first when a requested table needs the comparison actually performed: it does the analytical work, and Structured Output then renders its result into the format you named.
Concept Map — the structural-rendering relative for turning a tangle of related ideas into an explicit node-and-link diagram, when the shape you need is a graph of relationships rather than a table or fixed-field document.
Constraint Mapping — the upstream mode for when the “format” is really a set of hard requirements and trade-offs to lay out before anything is built or rendered, rather than a presentational shape to pour existing content into.