Scratchpad Prompting

The core mechanism is the dedicated context allocation for intermediate steps. Unlike a standard prompt where reasoning is implicit, the scratchpad provides a structured space (e.g., demarcated by tags like <<scratchpad>>) where the model writes its step-by-step logic before producing a final answer. This separates the reasoning process from the final output, making the model's 'working memory' transparent and inspectable. This is crucial for debugging complex reasoning and ensuring faithful chain-of-thought.

Scratchpad prompting enforces a strict output schema. The model is explicitly instructed to first use the scratchpad area and then provide a final answer in a specified format. Common patterns include:

• Dual-section prompts: Reasoning: [scratchpad]\n###\nFinal Answer: [answer]
• Programmatic separation: Using XML tags or code block fences to isolate the scratchpad. This structured approach is a precursor to more advanced structured output generation techniques like JSON or XML enforcement, reducing variability and improving parsing reliability for downstream systems.

The scratchpad acts as a non-volatile buffer within the context window. For multi-turn interactions or long, complex problems, the model can reference its own earlier scratchpad notes, simulating a form of short-term memory. This is distinct from the model's internal hidden states; it's an explicit, human-readable record. This persistence is key for tasks requiring iterative refinement or self-correction, as the model can review and amend its own prior reasoning steps explicitly listed in the scratchpad.

By externalizing the reasoning chain, scratchpad prompting mitigates reasoning collapse and operational errors. The model is less likely to skip steps or make silent arithmetic mistakes when it must write each step. This aligns with process supervision principles. It also allows for the application of stepwise verification, where each line of the scratchpad can be checked programmatically or by a secondary agent. This characteristic directly supports techniques like Chain-of-Verification (CoVe) and Self-Critique Prompting.

Scratchpad prompting is not an endpoint but a foundational primitive for more sophisticated reasoning frameworks:

• Program of Thoughts (PoT): The scratchpad naturally evolves to contain executable code snippets.
• ReAct (Reasoning + Acting): The scratchpad holds the 'Reasoning' step before an 'Action' (tool call) is taken.
• Tree of Thoughts (ToT): Multiple scratchpads can represent different branches in a reasoning tree.
• Self-Ask: The scratchpad holds the generated sub-questions and their answers. It provides the structural template upon which these agentic cognitive architectures are built.

Implementing scratchpad prompting requires careful context budget allocation. The scratchpad consumes tokens from the same fixed context window as the instruction and the final answer. Effective use involves:

• Instructional clarity to keep the scratchpad focused and avoid verbose meandering.
• Potential use of context compression techniques for very long reasoning traces.
• Strategic placement within the prompt to minimize recency bias. Poor management can lead to the scratchpad itself causing context truncation, defeating its purpose. This ties directly to the broader engineering challenge of context window management.

Scratchpad Prompting is foundational for solving multi-step arithmetic, algebra, and calculus problems. The model uses the allocated scratchpad to:

• Perform intermediate calculations step-by-step, reducing cumulative error.
• Track variable substitutions and algebraic manipulations.
• Execute generated code snippets in a Program of Thoughts (PoT) style, where Python code for calculation is written to the scratchpad before producing a final numeric answer. This method transforms the model's context from a static input to a dynamic worksheet, crucial for problems like "If a train leaves Station A at 60 mph..." where multiple interdependent values must be tracked.

This technique is essential for questions requiring synthesis of information from multiple, disparate pieces of context. The scratchpad acts as a working memory buffer where the model can:

• Explicitly list extracted facts from different parts of the provided documents.
• Draw logical connections between these facts to build a reasoning chain.
• Record sub-questions and their answers before synthesizing a final response. For example, when asked "What was the economic policy of the leader who succeeded the inventor of the lightbulb?", the model would use the scratchpad to note: 1. Lightbulb inventor: Thomas Edison. 2. Edison's successor in relevant context: [Extracted Name]. 3. That leader's economic policy: [Extracted Policy].

When tasked with explaining, debugging, or simulating code execution, a scratchpad allows the model to mimic a programmer's mental model. Key uses include:

• Manually tracing variable states through loops and conditional branches.
• Writing pseudo-execution logs (e.g., i=0, arr[0]=5, sum=5; i=1, arr[1]=3, sum=8;).
• Breaking down complex recursive calls by stacking activation records. This provides a transparent, step-by-step audit trail for the model's understanding, making its final explanation or bug diagnosis more reliable and verifiable than an intuitive, single-output response.

For tasks requiring the generation of a multi-step plan—such as project timelines, game strategies, or procedural instructions—the scratchpad serves as a dedicated planning space. The model can:

• List high-level goals and constraints.
• Decompose goals into sequential or parallel sub-tasks using a Least-to-Most approach.
• Evaluate potential dependencies or conflicts between steps.
• Iteratively refine the plan before outputting a finalized, structured list. This separates the messy, iterative planning process from the clean, final directive presented to the user.

Puzzles like logic grid puzzles ("Einstein's Riddle"), syllogisms, or scheduling problems with multiple constraints are ideally suited for scratchpad prompting. The model uses the space to:

• Create and populate a visual reasoning grid using text characters.
• Systematically apply constraints (e.g., "The blue house is not next to the doctor") to eliminate possibilities.
• Track positive deductions and propagate their implications. This externalizes the working memory needed to manage combinatorial possibilities, preventing the model from losing track of intermediate deductions in a long, complex chain of reasoning.

In domains like physics, biology, or economics, scratchpad prompting helps models reason through causal chains and system interactions. The model can:

• Diagram simple systems using text (e.g., A -> B -> C for causal links).
• Perform qualitative reasoning about equilibrium states or feedback loops.
• List known principles (e.g., laws of thermodynamics) and apply them stepwise to a scenario.
• Separate observation from inference, reducing the tendency to confabulate. This structured approach is a step toward more faithful Chain-of-Thought, where each step in the scratchpad has a verifiable role in reaching the conclusion.

The foundational technique that Scratchpad Prompting operationalizes. Chain-of-Thought (CoT) explicitly instructs a language model to articulate its intermediate reasoning steps before delivering a final answer. This decomposes complex problems, making the model's 'thinking' visible and significantly improving performance on arithmetic, commonsense, and symbolic reasoning tasks.

• Core Mechanism: Adds the instruction 'Let's think step by step' or provides few-shot examples with reasoning traces.
• Key Benefit: Transforms the model's output from an opaque answer to an interpretable reasoning chain.
• Direct Relationship: Scratchpad Prompting provides a dedicated, structured space within the context window where this CoT reasoning is performed and maintained.

A specialized reasoning paradigm where the model's 'scratchpad' is used to generate executable code. In Program of Thoughts (PoT), the language model writes code snippets (e.g., Python) as its intermediate reasoning step, which is then executed by an interpreter to obtain precise computational results.

• Scratchpad as Code Editor: The allocated context is used for writing, debugging, and sometimes explaining the generated program.
• Use Case: Ideal for mathematical calculations, algorithmic problems, and data manipulation where symbolic precision is critical.
• Advantage over Pure CoT: Offloads exact computation to a deterministic runtime, eliminating arithmetic hallucinations common in pure language-based reasoning.

A decoding strategy that leverages multiple reasoning 'scratchpads' to arrive at a more robust answer. Self-Consistency runs a Chain-of-Thought or Scratchpad prompt multiple times, sampling a diverse set of reasoning paths. The final answer is selected by a majority vote over the conclusions from each independent scratchpad.

• Process: 1. Generate N distinct reasoning traces (scratchpads). 2. Extract the final answer from each. 3. Choose the most frequent answer.
• Purpose: Mitigates the variability and potential errors in any single reasoning chain.
• Architectural Implication: Requires the model to generate and the system to manage multiple, separate reasoning contexts, highlighting the importance of scratchpad isolation and comparison.

A framework that extends the scratchpad concept to interleave reasoning with external actions. In ReAct, the model's working memory is used to maintain a trace of Thoughts, Actions, and Observations. The scratchpad tracks the plan, the executed tool/API call, and the result, creating a loop for dynamic problem-solving.

• Scratchpad Structure: Thought: I need to find the current weather. Action: search_api('London weather'). Observation: The API returns '22°C and sunny'.
• Key Difference: The scratchpad is not just for internal calculation but serves as the control flow and state memory for an interactive agent.
• Application: Enables reliable tool use, web navigation, and multi-step information gathering tasks.

A prompting framework that generalizes the linear scratchpad into a searchable graph of reasoning states. Tree of Thoughts (ToT) frames reasoning as a search problem where each 'thought' (node) is a coherent language sequence that serves as an intermediate step. The model uses its scratchpad to evaluate, explore, and backtrack through different reasoning branches.

• Beyond Linear Chains: Allows for exploration of multiple solution paths simultaneously.
• Scratchpad Role: Holds the current state of the search tree, candidate thoughts, and evaluation metrics.
• Use Case: Complex planning, creative writing, and strategic game play where a single chain of thought is insufficient.

A quality benchmark for the content generated within a scratchpad. Faithful Chain-of-Thought refers to a reasoning trace where the intermediate steps are logically coherent, factually correct, and genuinely instrumental in deriving the final answer—not a post-hoc rationalization.

• Critical Evaluation: Not all step-by-step output is faithful; models can generate plausible-but-incorrect reasoning.
• Implication for Scratchpad Design: Prompts must be engineered to elicit causal reasoning, not just descriptive narration.
• Verification Techniques: Methods like Stepwise Verification and Chain-of-Verification (CoVe) are used to check the faithfulness of each scratchpad step.