Apply to my task
arXiv:2507.17699 ★ 78 Jul 23, 2025

The Scratchpad Prompt: A Rough Draft Inside Your Request Unlocks Real LLM Reasoning

Key result

The paradox: models with "extended reasoning" barely beat regular LLMs when they have no external workspace. Zero magic, zero difference. The Scratchpad method lets any chatbot handle complex tasks much better, with no fine-tuning and no paid APIs. The trick: add a scratchpad tag to your prompt, a place where the model thinks out loud and records intermediate steps. After the scratchpad, it writes a clean final answer. The model stops juggling reasoning and output at the same time, and quality jumps sharply.

Thinking Isn't an Illusion: Overcoming the Limitations of ReasoningModelsvia Tool Augmentations

Key Aspects of the Research:

The study tests whether models trained to "think step by step" (as in Chain-of-Thought) really are better at solving hard problems. It turns out that without external "tools" their advantage is small or nonexistent. But when the models were given access to a "calculator" (a Python interpreter) and a "notepad" (a scratchpad for writing down intermediate steps), their performance jumped sharply, and they began consistently outperforming regular LLMs.

Key Result: LLM reasoning ability is not an illusion, but it only becomes truly effective when the model can "offload" complex calculations and intermediate steps to external tools or a dedicated workspace.


The Core of the Method, Explained:

The method you can take from this study for practical prompting comes down to separating the thinking process from the final result inside the prompt itself. Instead of asking the LLM to deliver a finished complex answer right away, we create a simulation of the "tools" described in the paper.

This is done through two key concepts adapted for everyday users:

  1. Simulating a "Scratchpad" (notepad/rough draft): We explicitly set aside a special area in the prompt where the model has to do all its reasoning, take notes, test hypotheses and track the state of the task. That's its "notepad". We flatly forbid it from writing the final answer in that area.

  2. Simulating an "Interpreter" (a logic calculator): For tasks that require logic or sequential actions, we instruct the model, inside the "notepad", to act as a strict executor: break the task into elementary steps, analyze the constraints, and only then synthesize a solution.

The technique for users: For any complex task that involves planning, analysis or multi-step reasoning, structure your prompt like this: * Step 1. Define the role and the task. State clearly who the model should be and what the end goal is. * Step 2. Create a "Workspace". Use Markdown or XML tags (for example, <scratchpad> or ## Scratch notes) to mark off a place for intermediate reasoning. * Step 3. Give instructions for using the "Workspace". Tell the model directly: "First think step by step inside the <scratchpad> tag. Analyze all the data and make a plan. Don't write the final answer here." * Step 4. Ask for the final result. After the closing workspace tag, ask the model: "Now, based on the reasoning in <scratchpad>, provide a final, clean and structured answer."

This approach makes the LLM fully "think through" the task in an isolated space first, without trying to generate and format the final answer at the same time. That lowers the model's cognitive load and, as the study proves, dramatically improves the quality of the result.


Practical Applicability Analysis:

  • Direct applicability: Users can immediately apply an adapted "scratchpad" method in any chatbot. All it takes is using special sections in the prompt, for example Markdown headings (## Workspace, ## Final Answer) or XML tags (<thinking_space>, <final_answer>), and telling the model to think in one section first and then write the answer in the other.

  • Conceptual value: The study gives users a powerful mental model: an LLM has limited "working memory". When a task is complex, the model "forgets" the initial conditions or gets tangled in its own reasoning. Providing a "notepad" in the prompt is a way to extend that memory, letting the model track its progress and stay on course.

  • Adaptation potential: The method adapts easily to any complex task.

    • Planning: Trips, events, budgets.
    • Analysis: Comparing products, analyzing reviews, breaking down a complex text.
    • Creative work: Writing a script, developing a book plot, building a marketing campaign.

    The adaptation mechanism is simple: any task a person would tackle with a pen and a sheet of paper, jotting down notes, is a perfect candidate for this approach with an LLM.


Practical Example:

You are an experienced event manager. Your job is to plan an outdoor corporate event for a 50-person tech company.

**Constraints:**
- Budget: $15,000.
- Date: the last Saturday in August.
- Goals: team building, relaxation, informal socializing.
- Wishes: active games, good food (including vegetarian options), memorable swag.

**Instructions:**

1.  **Use the `` workspace for step-by-step planning.** Inside this tag you should:
    *   Analyze all the constraints and goals.
    *   Suggest 2-3 venue options outside Chicago.
    *   Split the budget across the main line items: venue rental, catering, transportation, activities, swag.
    *   Sketch out an event schedule from 12:00 PM to 9:00 PM.
    *   Come up with team-building and swag ideas.
    *   Don't write the final plan here! These are just your notes and calculations.

2.  **Once you've finished working in ``, write the final plan in the `` tag.** It should be a clean, structured document ready to present to the client.







Why It Works:

This prompt works thanks to several mechanics that follow directly from the study's findings:

  • Forced decomposition: The instructions stop the model from generating an answer right away and make it break the complex task ("plan an event") into a series of small, manageable subtasks (pick a venue, split the budget, build a schedule).
  • External memory (a simulated Scratchpad): The <SCRATCHPAD> tag serves as a "notepad". By writing its intermediate conclusions there (for example, "Food budget: $5,000, that's $100 per person"), the model locks in the state of the task and can refer back to it in later steps without "forgetting" or contradicting itself.
  • Lower cognitive load: The model first focuses purely on free-form analysis and planning, and only then on structuring and formatting the clean answer. Just as with people, splitting the work this way improves the quality of each part.

Another Practical Example

You are an experienced marketer and content strategist. You need to build a one-week content plan for the Instagram account of a new organic skincare brand.

**Target audience:** Women aged 25-40 interested in eco-friendly living, yoga and natural skincare.

**Goals for the week:**
- Raise awareness of the flagship product (a vitamin C serum).
- Increase engagement (likes, comments, saves).
- Gain 300 new followers.

**Instructions:**

1.  **First, do all the prep work in the "## Analysis Workspace" section.** In this section:
    *   Define the key content pillars (for example: "Ingredient Benefits", "Behind the Scenes", "Reviews", "Eco Tips").
    *   Spread the pillars and formats (Post, Reels, Stories) across the days of the week.
    *   Come up with specific topics for posts and Reels aimed at the week's goals.
    *   Think up ideas for interactive Stories (polls, quizzes).

2.  **Once you've finished the analysis, present the finished content plan in the "## Final Content Plan" section as a table.**

## Analysis Workspace
*This is where the model will brainstorm and take notes.*

## Final Content Plan
*This is where the model will present the final table.*

Why This Example Works: The Mechanism

This prompt is effective because it simulates a strategist's real workflow, which the study's findings back up:

  • Strategy before tactics: The "Analysis Workspace" section makes the model think strategically first (define pillars and goals) before moving on to tactics (writing specific posts). That prevents random, disconnected content.
  • Locking in intermediate decisions: The model writes down its ideas on pillars and formats. These serve as "anchors" when it builds the final table, ensuring all the initial ideas are accounted for and logically connected.
  • Structured output: Requiring the final result as a table forces the model not just to list ideas but to synthesize them into a clear, ready-to-use working document. Separating the "brainstorm" from the "final report" produces a far higher-quality, better-structured result.

Usefulness Score: 83

02

Main Evaluation Criteria

  • A. Relevance to prompting techniques: Low directly, but high conceptually. The study doesn't offer new phrases, but it proves the effectiveness of a methodology you can simulate in prompts (using a "workspace" or "scratchpad").
  • B. Improving the quality of conversational answers: High. The methods described in the study dramatically improve accuracy on complex, multi-step tasks, which translates directly into better, more reliable answers.
  • C. Direct practical applicability: Low. The main methods (a Python interpreter, an API-driven scratchpad) require programming tools and aren't available to a regular user in the ChatGPT interface. However, the "scratchpad" concept can be adapted.
  • D. Conceptual value: Very high. The study brilliantly explains why LLMs fail at complex tasks (limits on "working memory" and output length) and how to overcome that. It gives users the right "mental model" of an LLM: not an all-knowing oracle but a powerful yet limited processor that needs tools and a workspace.
  • E. A useful new practice (clustering): The work falls into several clusters:
    • Cluster 2 (LLM behavioral patterns): Shows how performance drops sharply once reasoning passes a certain threshold of complexity/length.
    • Cluster 6 (Context and memory): The "scratchpad" method is essentially a strategy for managing memory and context on long tasks.
    • Cluster 7 (Reliability and stability): Using external tools (an interpreter) is a way to improve reliability and reduce hallucinations in tasks that need precise calculations.
  • Practicality checklist (+15 points): Yes. The study conceptually shows how to structure complex requests, reveals non-obvious features of LLM behavior ("thinking" falling flat without tools) and offers ways to dramatically improve answer accuracy.
03

Numerical Usefulness Score

The score of 83 points reflects the study's huge conceptual value and the strong potential for adapting its findings into advanced prompts, despite the low direct applicability of the described tools for a regular user.

Arguments for the score: * A fundamental insight: The main finding, that "thinking" (Chain-of-Thought) only reaches its potential when "tools" (a calculator, a notepad) are available, is one of the keys to understanding modern prompt engineering. * Practical adaptation: The "scratchpad" (rough draft/workspace) idea carries over easily into a prompt via markup (XML tags, Markdown), letting users simulate the proposed approach and significantly improve results on complex tasks. * Explaining the "why": The study gives users a clear understanding of why their complex request might fail and offers a mental model for fixing it: "give the model a place for intermediate thoughts".

Counterarguments (why the score could be lower): * Adaptation required: Users can't just pick up and use a "Python interpreter". They have to figure out how to simulate the approach through prompt instructions, which takes a certain level of abstract thinking. * Focus on code: A large part of the study is devoted to Program-of-Thought (PoT), which may scare off a non-technical audience and give the impression that the findings only apply to programming tasks.


Research digest

Key result

The paradox: models with "extended reasoning" barely beat regular LLMs when they have no external workspace. Zero magic, zero difference. The Scratchpad method lets any chatbot handle complex tasks much better, with no fine-tuning and no paid APIs. The trick: add a scratchpad tag to your prompt, a place where the model thinks out loud and records intermediate steps. After the scratchpad, it writes a clean final answer. The model stops juggling reasoning and output at the same time, and quality jumps sharply.

Principle

An LLM is like a student taking an exam without scratch paper: holding everything in their head, getting confused, forgetting the initial conditions. Give it scratch paper and the picture changes. Split the prompt into two isolated stages: think first, then answer. Stage 1: the `` tag holds all the analysis, options, calculations and contradictions. The final answer doesn't go there. Stage 2: the `` tag holds a clean, structured result based on the scratchpad. The model sees everything it wrote down and doesn't lose the thread.

Why it works

An LLM has limited working memory. The longer the chain of reasoning, the higher the chance it loses a key condition, or starts contradicting itself. The scratchpad works as external memory: the model records intermediate conclusions and refers back to them in later steps. That's exactly what the external tools in the study do: a Python interpreter and a notepad. Simulating them with structural tags in the prompt gives the same effect.

When to apply

Any task with several variables or steps. Planning: an event, a trip, a budget. Analysis: comparing options, breaking down a complex text, assessing risks. Creative work: a script, a marketing campaign, product development. Simple rule: if you'd solve the task yourself with a sheet of paper, it's a candidate for a scratchpad prompt. NOT a fit for simple factual questions; there the scratchpad just bloats the prompt for no benefit.

Mini recipe

1. Set the role and goal: Clearly describe who the model should be and what you need as output. 2. List all the constraints: Conditions, data, wishes, before the thinking instructions. 3. Create the scratchpad: Add a `` section or `## Workspace`. Say it directly: "Analyze here, build options, do the math. Don't write the final answer here." 4. Ask for the clean copy: After the scratchpad, add `` or `## Final Answer`. Ask: "Based on the workspace, write a clean, structured result."

Examples

[BAD]: `Plan a company outing for 50 people, budget $15k, a Saturday in August, team building and food` [GOOD]: `You are an experienced event manager. Task: an outdoor company event for a tech company, 50 people. Budget: $15,000. Date: the last Saturday in August. Goals: team building, relaxation, informal socializing. Wishes: active games, food with vegetarian options, swag. Do all the analysis here: — 2-3 venue options — budget split by line item — schedule from 12:00 PM to 9:00 PM — team-building and swag ideas Don't write the final plan here. Based on the workspace, write a ready-to-go event plan, structured, with budget and schedule. `

In plain words

Here's the thing: today's "thinking" models like o1 or DeepSeek-R1 are actually locked inside their own heads. When a model builds a long chain of thought (Chain-of-Thought), it relies only on its memory, which often lets it down. The study proves that if a model just "thinks" for a long time about a hard problem without access to external tools, it starts piling up mistakes and hallucinating. It's a fundamental barrier: internal logic breaks down when data is missing or out of date.

It's like trying to assemble a complicated IKEA wardrobe in pitch darkness, going purely on instinct. You could be an engineering genius, but without the instructions and a flashlight you'll inevitably drive a screw into the wrong spot. Technically you tried really hard, but the wardrobe will fall apart. Tools, in this case, are that flashlight and those instructions, letting the model stop guessing and start checking facts in real time.

To break through this ceiling, the authors propose Tool Augmentation: pairing deep reasoning with external crutches like Google search or a calculator. It works like this: the model doesn't just spit out an answer; it first builds a plan, figures out where its "blind spot" is, and goes out into the world for data. The key method here is interactive refinement, where the model uses a Python script or an API to confirm its guesses. That turns it from an overconfident fantasist into a meticulous analyst who double-checks every step.

Although the experiments were run on math and coding, the principle is universal. It applies everywhere, from drafting legal contracts to planning trips. If you ask an AI to put together an itinerary, a regular model might suggest a museum that's closed for renovation because "that's how it remembers it". A model with tools is next-level GEO: it checks opening hours via search first and only then works them into its reasoning. Any serious work with data now requires not just "smarts" but the ability to use tools.

Bottom line: pure model "thinking" is cool, but without external tools it quickly hits a dead end. The study's main takeaway is that tools fix logical failures that can't be cured just by making the model bigger. If you want results without screw-ups, make the model not just think but go online and use a calculator. Anyone who keeps using "bare" prompts for complex tasks will keep getting confident nonsense instead of working solutions.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on The Scratchpad Prompt: A Rough Draft Inside Your Request Unlocks Real LLM Reasoning arXiv:2507.17699

Sign in to apply this study New accounts get 50 free credits.

Get the week’s best papers by email

One email on Sundays with the highest-rated new techniques. Unsubscribe with one click.