Does an AI write long answers because each step depends on the last, or just because you asked for length?

This explores whether long outputs held together by step-by-step dependency behave differently from long outputs produced because an instruction asked for them. No note in the corpus tests the two side by side, so what follows is a synthesis from adjacent findings, not a documented result.

Start with the instruction side. Instruction tuning appears to teach the shape of the output more than the task: models trained on empty or even deliberately wrong instructions score about the same as models trained on correct ones (Does instruction tuning teach task understanding or output format?). If that holds for length too, an instruction like 'think step by step at length' gets you something that looks like a long chain. The same pattern shows up in reasoning traces: length tracks difficulty only on problems near the training distribution, and decouples from it elsewhere (Does longer reasoning actually mean harder problems?). Chain-of-thought looks like constrained imitation of reasoning form, not inference (Does chain-of-thought reasoning reveal genuine inference or pattern matching?, Why does chain-of-thought reasoning fail in predictable ways?). Even the best length isn't 'as long as possible'. Accuracy peaks at a middle length, and RL training pushes models toward shorter chains as they improve (Why does chain of thought accuracy eventually decline with length?).

The causal side has a useful test. Fine-tuned models produce reasoning chains that matter less to the final answer. Cut the chain short, paraphrase it, or swap in filler, and the answer stays the same more often (Does fine-tuning disconnect reasoning steps from final answers?). That gives a working definition (my reading, not the paper's wording). A chain is causal when removing a step changes the outcome. A chain is instruction-shaped when its length is decoration. So a causal chain enforces length because every link is load-bearing, whereas an instruction can only ask for length.

The corpus also shows two ways to make the dependency real by building it into the system instead of asking the model for it. LLM Programs put an explicit algorithm in charge of control flow. Each model call sees only the context its own step needs, so the number and order of steps live in the program, not in the model's willingness to keep going (Can algorithms control LLM reasoning better than LLMs alone?). The Thread Inference Model does something similar inside one model. It structures reasoning as recursive subtask trees and prunes the KV cache down to what the current branch needs, which lets reasoning run past the context limit (Can recursive subtask trees overcome context window limits?). In both, horizon length is a property of the dependency structure. Neither depends on how long an instruction says to go.

Structure doesn't guarantee competence, though. Frontier reasoning models reach only 20–23% exact match on constraint problems that require real backtracking, even though their reflection reads fluently (Can reasoning models actually sustain long-chain reflection?). A separate line of work suggests the long-context bottleneck is the compute needed to turn old context into usable internal state, not memory capacity (Is long-context bottleneck really about memory or compute?). The corpus also has two notes on how LLMs reason about cause and effect. They are a different question, but they show the model's handling of causal links is uneven. LLMs are better with explicit causal connectives than with implicit temporal order (Why do LLMs handle causal reasoning better than temporal reasoning?), and they share human errors such as weak explaining-away (Do large language models make the same causal reasoning mistakes as humans?).