Scratchpad

The scratchpad's primary function is to make the model's intermediate reasoning visible and persistent. Unlike a human's internal monologue, it is an explicit output where the model writes down provisional calculations, logical deductions, or planning steps before committing to a final answer. This separates the working memory of the problem-solving process from the final communicative output, preventing the loss of crucial step-by-step logic.

A well-designed scratchpad uses a clear, often semi-structured format to facilitate later parsing by the model itself or an external system. Common patterns include:

• Numbered steps for sequential logic.
• Delimiters like --- or ### to separate planning from execution.
• Code blocks for computations in frameworks like Program-Aided Language Models (PAL).
• Key-value pairs for storing retrieved facts or variable assignments. This structure enables techniques like ReWOO (Reasoning Without Observation), where a planner generates a scratchpad-based plan for separate executors to follow.

By externalizing the reasoning chain, the scratchpad allows for post-hoc verification and debugging of the model's process. This is critical for:

• Faithfulness Evaluation: Auditors can check if the final answer logically follows from the recorded steps.
• Error Identification: Mistakes can be pinpointed to a specific step (e.g., a miscalculation or a flawed assumption) rather than just the final output.
• Process Supervision: Training systems can provide reward signals for each correct intermediate step, not just the final outcome, leading to more reliable reasoning.

The scratchpad is not just a notepad; it's the foundational substrate for advanced reasoning architectures. It enables:

• Tree-of-Thoughts (ToT): Multiple reasoning paths can be explored and written in parallel branches of the scratchpad for evaluation.
• Self-Consistency: Multiple scratchpad traces for the same problem can be generated and compared, with the most frequent final answer selected.
• Chain-of-Verification (CoVe): The model can use the scratchpad to plan and record a series of fact-checking queries against its initial answer.
• Tool-Augmented Reasoning: The scratchpad can clearly indicate where a tool call (e.g., CALCULATOR(12 * 5)) is needed and record its result.

The scratchpad enforces a clean architectural separation between different cognitive phases. A typical flow is:

1. Problem Analysis: Decomposing the query in the scratchpad.
2. Planning/Reasoning: Writing the step-by-step logic.
3. Computation/Retrieval: Noting where external tools are used.
4. Synthesis: Combining intermediate results.
5. Final Answer Generation: Producing a concise, polished response based on the scratchpad's conclusions. This mirrors software engineering principles, making the agent's behavior more modular, predictable, and easier to optimize.

For complex, multi-turn tasks, the scratchpad acts as a short-term working memory that persists across model calls or agent steps. It maintains the state of the ongoing plan, tracks completed sub-goals, and holds relevant intermediate data. This prevents the model from losing track of progress in long conversations or workflows and is a simpler, more controllable alternative to relying solely on the model's internal context window, which can be limited and prone to distraction.

The foundational prompting technique that popularized explicit step-by-step reasoning. It involves providing the model with few-shot examples that demonstrate a complete reasoning trace before the final answer. This technique teaches the model to decompose complex problems and articulate its logic, significantly improving performance on arithmetic, commonsense, and symbolic reasoning tasks.

A framework that interleaves verbalized reasoning with executable actions. The model's scratchpad alternates between 'Thought:', 'Action:', and 'Observation:' steps. This allows the agent to:

• Plan dynamically based on environmental feedback.
• Use tools and APIs (e.g., calculators, search) within its reasoning loop.
• Handle open-world problems where the solution path isn't known in advance.

A technique where the model's scratchpad consists of executable code (typically Python). The model writes code that represents its reasoning steps, and an external interpreter executes it to get the final answer. This is particularly powerful for:

• Mathematical and algorithmic problems requiring precise computation.
• Data manipulation tasks.
• Offloading computation to a reliable, deterministic runtime, reducing symbolic and arithmetic errors from the LLM itself.

A generalization of the linear scratchpad into a branching exploration space. Instead of one chain of thought, the model generates multiple possible reasoning steps at each point, creating a tree. This framework involves:

• A thought generator to propose next steps.
• A state evaluator to score the promise of different paths.
• A search algorithm (e.g., BFS, DFS) to explore the tree. It is used for complex problems like game playing, creative writing, and strategic planning where backtracking is necessary.

A decoding and aggregation strategy used to improve the reliability of scratchpad-based reasoning. Instead of generating a single chain of thought, the model is sampled multiple times to produce multiple diverse reasoning paths. The final answer is determined by majority voting over the final answers from each path. This technique mitigates the variability and potential errors in any single reasoning trace.

A method that uses a dedicated verification scratchpad. The model follows a four-stage process:

1. Draft an initial baseline response.
2. Plan verification questions to fact-check the draft.
3. Execute the verification plan, potentially using tools.
4. Generate a final, revised answer based on the verification results. This introduces a self-critique and fact-checking loop separate from the initial reasoning chain, significantly improving factual accuracy and reducing hallucinations.