TL;DR
Structure of Thought (SoT) is a prompting technique that makes the model first build a map of the text (nodes + links) and only then answer the question. Not “think step by step” like Chain-of-Thought, but “extract the structure first, then use it.”
When you ask an LLM to make sense of a long text — a contract, an article, a technical spec — the model reads it like a news ticker: left to right, with no “map.” So on complex questions it mixes up who influences whom, loses chains of dependencies, and confuses causes with effects. Chain-of-Thought adds reasoning, but that reasoning can wander off — the model fills in gaps instead of sticking to the text.
SoT fixes this in one move: before answering, the model explicitly names the key nodes (entities, concepts, components) and links (relationships between them). That pins the reasoning to the text, keeps it from drifting into hallucinations — and only then does the model answer the question, relying on the map.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
One prompt, two steps:
STEP 1 — Structuring
Nodes: [list of key entities/concepts from the text]
Links: [A] → [B]: [link type], [B] → [C]: [link type]...
STEP 2 — Answer
Using the extracted structure → answer the question
Both steps run in a single prompt; the model does them in order on its own.
Example in Action
Task: Ryan is the COO of a startup. He's received an 8-page term sheet from a potential investor. He needs to figure out who controls which decisions, where the founders could lose power, and which triggers protect the investor.
Prompt:
Read the term sheet text below and complete two steps.
Step 1 — Structuring:
Extract the key NODES from the text (parties, rights, mechanisms, triggers)
and the LINKS between them.
Format:
Nodes: [Node 1], [Node 2], [Node 3]...
Links: [Node A] → [Node B]: [link type / condition]
Step 2 — Answer:
Using the extracted structure, answer:
In which situations do the founders lose control over decisions?
List the specific triggers.
Term sheet text:
[paste text]
Result: The model will first show the map: nodes (Founders, Investor, Board of Directors, Veto right, Anti-dilution, Liquidation preference) and the links between them with conditions. Then it answers the question based on that map — not on general knowledge about term sheets. The answer stays tied to this specific text, with exact clauses.
Why It Works
The problem: An LLM reads text sequentially and generates the answer right away. With long or complex texts it can't hold the full picture of links in its head — especially when it has to go through several hops (“A affects B, B affects C, therefore...”). It's like trying to describe a subway map without looking at it.
What the model is good at: It extracts structure from text well when explicitly asked to. It reasons well over a ready-made structure. Taken separately, both steps are easy for it.
How SoT uses this: It splits one hard task (“make sense of the text and answer”) into two easy ones (“build a map” → “answer from the map”). The map becomes an intermediate representation — an anchor the reasoning is tied to. It cuts off hallucinations: the model can't write about a link that isn't in the text if it didn't just extract it itself.
Control knobs:
| What to change | Effect |
|---|---|
| Node/link format | JSON, table, list — whatever format you need |
| Node granularity | Fewer nodes → faster, bigger picture. More → more precise |
| Link type | Only cause-and-effect / only temporal → focus |
| Drop “using the structure” | The model answers from the structure, but without explicitly referencing it |
Prompt Template
Read the following text and complete two steps.
Step 1 — Extract the structure:
Identify the key NODES (main entities, concepts, components)
and the LINKS (relationships, dependencies, influences) between them.
Nodes: [Node 1], [Node 2], [Node 3]...
Links: [Node A] → [Node B]: [link type], [Node B] → [Node C]: [link type]...
Step 2 — Answer the question:
Using the extracted structure, answer: {question}
Text:
{text}
Placeholders:
- {question} — what exactly you need to understand or do with the text
- {text} — any long/complex text: a contract, an article, a process description, an interview
🚀 Quick start — paste into the chat:
Here is a Structure of Thought template. Adapt it to my task: [your task].
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask about the nature of the text and what exactly you need to understand — because that determines which nodes and links are worth extracting (cause-and-effect, process, hierarchical). It will take the pattern from the template and adapt it to your task.
Limitations
⚠️ Simple tasks: If the text is short and the question direct, SoT adds extra steps with no payoff. It shines where the structure is genuinely complex.
⚠️ Subjective judgments: If the question is “how persuasive is the writing,” a node/link structure barely helps. The method is strong for structural and logical tasks, not aesthetic ones.
⚠️ Weak models: Small local models may extract structure poorly — and then the map and the answer will be equally wrong. It works well on GPT-4o, Claude and Gemini.
⚠️ No explicit prompt in the paper: The exact SoT system prompt is in Appendix C, which isn't publicly available. The template above is built from the description of the mechanics in the text and reproduces the essence of the method.
How They Tested It
A team from Duke University took three model families (Qwen2.5-7B, GPT-4o, Llama 3.1-8B) and ran three prompting strategies — direct answer, Chain-of-Thought and SoT — across eight text-processing tasks. The tasks covered all the essentials: multi-hop questions, summarization, working with multiple sources. The result was surprisingly consistent: SoT won almost everywhere, and CoT didn't. The contrast was sharpest on 2WikiMultiHopQA and MuSiQue, where you have to make several reasoning hops through the text: CoT sometimes even hurt results compared with a direct answer, while SoT delivered +10% or more. That's the key insight: CoT adds reasoning steps, but they can drift away from the text — SoT anchors the reasoning to the structure of the text itself, and that's a fundamental difference.
The researchers also built the T2S-Bench benchmark — 1,800 examples from real research papers across six disciplines, with 32 structure types. 45 models took the test: average accuracy on multi-hop tasks was 52.1%, and the best model on end-to-end structure extraction hit 58.1%. That means even top models are bad at structuring text — which explains why an explicit structuring prompt helps so much.
Original Prompt from the Paper
The exact SoT prompt is in Appendix C of the paper, which isn't included in the public version of the preprint. The authors describe the format as an instruction to extract key nodes and links before generating the final answer. The closest reconstruction from the description:
Given the following text, first extract the key nodes
(main entities, concepts, or components) and links
(relationships, dependencies, or interactions)
to build a text structure:
Nodes: [Node 1], [Node 2], [Node 3]...
Links: [Node A] → [Node B]: [relationship type],
[Node B] → [Node C]: [relationship type]...
Then, using this extracted structure, answer the question:
{question}
Text: {text}
Context: The researchers used this format as a universal prompt for all eight tasks without modification — universality was the whole point.
Adaptations and Extrapolations
💡 Adaptation: analyzing email threads or feedback
SoT works well not only on documents but also on complex communication — say, a long email thread or customer reviews.
Read the email thread below and complete two steps.
Step 1 — Extract the structure:
Nodes: [parties, key demands, pain points, agreements]
Links: [who wants what from whom, what's blocking, what's already agreed]
Step 2 — Answer:
Using the structure: what is the main conflict, and what needs to happen
to move the negotiation forward?
Thread:
{thread text}
🔧 Technique: typed nodes → a sharper map
Add explicit types to the nodes and the model will draw cleaner distinctions:
Step 1 — Extract the structure:
Nodes:
- [Actors]: who is involved
- [Resources]: what is transferred / used
- [Conditions]: under what circumstances
- [Outcomes]: what happens in the end
Links: [Node A] → [Node B]: [link type]
Explicit categories reduce the risk of the model lumping “the company” and “a contract condition” into one pile.
🔧 Technique: SoT + a critical question
Once the map is built, ask a provocative question about the structure:
Step 2 — Answer two questions:
1. What in this structure looks illogical or contradictory?
2. Which node is the single point of failure for the whole system?
Useful for process audits, risk analysis, and picking apart other people's business models.
Resources
Paper: T2S-Bench & Structure-of-Thought: Benchmarking and Prompting Comprehensive Text-to-Structure Reasoning
Project site: https://t2s-bench.github.io/T2S-Bench-Page/
Authors: Qinsi Wang, Hancheng Ye, Jinhee Kim, Jinghan Ke, Yifei Wang, Martin Kuo, Zishan Shao, Dongting Li, Yueqian Lin, Ting Jiang, Chiyue Wei, Qi Qian, Wei Wen, Helen Li, Yiran Chen
Institutions: Duke University, UT Austin, Meta