Reasoning traces

A reasoning prompt asks for stages before the final answer. Each stage holds one intermediate result, such as a partial sum.

The trace below is schematic, not a real reply from any system. It shows stages that a checker can follow by hand.

1
2
3
4

schematic transcript, invented for illustration
USER: Add 14, 27, and 35. Show each partial sum, then the total.
MODEL (schematic): 14 + 27 = 41. 41 + 35 = 76. Total 76.
CHECK: 14 + 27 = 41, 41 + 35 = 76. Each line re-adds exactly.

When staging helps

For a timing calculation, ask for the stated assumptions, formula, substituted numbers, units and result. This is a checkable explanation, not a demand for private internal reasoning. Whether a longer explanation improves task performance depends on the setup; measure correctness and review effort rather than assuming more text is better.

The program below deliberately compares incorrect arithmetic (sum plus ten) with correct arithmetic. It tests the checker on known defects; it cannot establish that reasoning prompts improve an AI model.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import sys

def direct(items):
    return sum(items) + 10

def step_by_step(items):
    total = 0
    for x in items:
        total = total + x
    return total

CASES = [[1, 2, 3], [10, 20, 30], [4, 5, 6, 7]]

direct_ok = 0
steps_ok = 0
for items in CASES:
    if direct(items) == sum(items):
        direct_ok = direct_ok + 1
    if step_by_step(items) == sum(items):
        steps_ok = steps_ok + 1

if direct_ok == 0:
    pass
else:
    print("FAIL: direct count changed")
    sys.exit(1)
if steps_ok == 3:
    pass
else:
    print("FAIL: staged count changed")
    sys.exit(1)
if 9 ** 4 == 6561:
    pass
else:
    print("FAIL: power changed")
    sys.exit(1)
print("PASS: checker detects 3 intentionally biased results and accepts 3 correct sums; no model evaluated")

Cost and limits

Stages emit extra output tokens on every request. Temperature rescales the sampling distribution, and temperature 0 is approximately greedy rather than a guarantee of identical output across runs or hardware.

The probability calculation below assumes independent steps with equal success rates and no recovery. Real agent steps may share errors or correct earlier ones, so it is not a prediction of model reliability. Skip this optional arithmetic if your task is simply to check a report.

1
2
3
4
5

EXAMPLE per-step success p = 0.9, steps n = 4
chain = p^n = 0.9^4 = (9/10)^4 = 6561/10000 = 0.6561
second EXAMPLE: p = 0.8, n = 3 -> (8/10)^3 = 512/1000 = 0.512
reasoning output 400 tokens x 10000 requests = 4000000 = 4M
extra output cost = 4 x 9 = 36 units at EXAMPLE 9 units per 1M

Common mistakes

A fluent trace can still hide a wrong line. Trust comes from recomputing, not from tone.

Related topics

• Self-checks and structured output

• Verifying AI output

• Self-checking regression