Apply to my task
arXiv:2608.12847 ★ 79 Aug 13, 2026

QCR (Query-Conditioned Reuse): Extracting an Action Template from Past Experience Instead of Copying the Whole History

Key result

The paradox: the longer the past conversation you paste into the prompt, the worse the new result. The model starts dragging in the old client's name, the old date, the old order number — as if they were the answer for the new task. The QCR method lets you reuse a successful past case (a negotiation, an email, a report) for a similar new task without the risk of the model accidentally copying someone else's data. Instead of the whole history, the model compresses it into a 4-field note: what to do the same way, which values to re-check, when the template doesn't fit, how to verify the result.

01

TL;DR

QCR is a technique for reusing an LLM's past experience: instead of pasting the entire history of solving a similar task into the prompt, the model first turns it into a compact four-part note — which action template stays the same, which values need to be re-checked (names, dates, numbers — anything that changed), when this template doesn't apply at all, and how to verify the final result.

The key finding: the longer the past history you copy into the prompt for a new similar task, the worse the result. The model starts literally copying old details — the previous client's name, an old order number, an outdated date — instead of finding the current values for the new task. The full history doesn't help so much through its volume as it contaminates the context with stale facts, and that outweighs the benefit of having more information.

QCR solves this with an explicit split: before showing the model a past success, it's turned into a short note with four fields — what to always do the same way, what needs to be found out again, when not to use this template, how to check that everything was done right. The model works with this note, not with the raw history.

Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.

02

Method Blueprint

STEP 1 (separate request): Give the model a past successful example of solving a similar task
→ ask it to break it down into 4 fields:
   1. Workflow — the unchanging sequence of actions
   2. Bindings — specific values that must be RE-checked/found out again
   3. Applicability — conditions under which this template does NOT fit
   4. Verification — how to check the final result
→ output format: a short note (half the length of the original history)

STEP 2 (new request): Give the model this note + a description of the new task
→ the model solves the new task using the template, but doesn't drag in old values
→ output format: the solution to the new task + an explicit check against the guardrail
03

Example in Action

Task: A recruiter negotiated with a candidate for a manager role and closed the deal: agreed on salary, start date, and discussed relocation. Now they need to run the same kind of negotiation with a new candidate for a similar role, but with different terms.

Prompt (step 1):

Here's a thread where I successfully reached an agreement with a candidate, Jake, to hire him as a 
sales manager ($95k salary, start date March 1, no relocation):

{paste the thread}

Break this successful case down into 4 parts:
1. Workflow — which sequence of negotiation steps worked (regardless of the details)
2. Bindings — which specific values (salary, dates, terms) 
   I'll need to find out/discuss again with a new candidate rather than take from this case
3. Applicability — in which situations this negotiation approach won't work
4. Verification — how to check that the negotiation with the new candidate went just as well

Give me a short note, without quoting the old thread.

Result: The model produces a compact 4-point note: for example, workflow — "first state the salary range, then discuss non-monetary terms, then lock in the start date in writing"; bindings — "salary, start date, relocation — all of these need to be discussed from scratch with the new candidate"; applicability — "the approach won't work if the candidate already has a competing offer with a deadline"; verification — "the negotiation succeeded if the candidate confirmed the start date in writing." You can then paste this note into a new conversation about negotiating with the next candidate — with no risk that the model accidentally offers the new person Jake's salary or start date.

04

Why It Works

An LLM's weakness: when the context holds a long past history with specific names, dates and figures, the model tends to literally repeat those values for the new task — they're "right there" and look like a ready-made answer, even if they're no longer relevant. This isn't a logic error; it's the effect of every detail in the context looking equally important, so old specific numbers are indistinguishable from current ones for the model.

An LLM's strength: the model is great at separating the general from the specific if you ask it explicitly — pulling out a pattern separately from the specific numbers is a standard structure-extraction task that LLMs handle well.

QCR uses this: it makes the model first explicitly name what in the past case is a rule and what is a temporary value that needs re-checking. From then on the model works not with the full text but with this markup, and it has no temptation to copy an old number, because right next to it is the explicit note "this needs to be found out again."

Control levers: - Number of fields (4) → for simple repetitive tasks you can trim to 2 (workflow + bindings); for high-risk tasks (legal documents, finance) add more verification conditions. - The Verification field → rephrase it for your task ("check that the amount matches the contract" instead of a generic "check the result"). - Applicability → explicitly add your own conditions for not reusing the template — this protects against blindly copying the approach where it doesn't fit.

05

Prompt Template

Here is a successful past case of solving a similar task:

{text of the past thread/solution}

New task:
{description of the new task}

Break the past case into 4 parts and give a short note (without quoting the original text):

1. Workflow — which sequence of actions/approach worked and is still relevant
2. Bindings — which specific values (names, dates, numbers, terms) from the past case 
   do NOT fit the new task and must be obtained/clarified again
3. Applicability — under what conditions this approach doesn't apply to the new task at all 
   (when it's better not to use this template)
4. Verification — how to check that the new task was solved as successfully as the past one

Use this note to solve the new task — don't copy values from the past case.

Fill in: {text of the past thread/solution} — any past successful result (a negotiation, an email, a report, code, a plan); {description of the new task} — a new similar situation with different details.

🚀 Quick start — paste into a chat:

Here is the QCR template (reusing past experience). Adapt it to my task: 
{your task}. Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask which past case to use and what exactly changed in the new task — because without that it can't separate the "rule" from the "values to re-check." It will take the structure from the template and adapt it to your situation.

06

Limitations

⚠️ You need a genuinely similar past example: if you don't have a successful past case with a similar task structure, QCR has nothing to extract a template from — the method doesn't create experience from scratch, it only repackages what already exists.

⚠️ Doesn't work if the tasks are structurally different: the method helps when the details change (names, dates, numbers) but the approach to the task stays the same. If the new task needs different solution logic, the note won't save you.

⚠️ You have to find the past example by hand: in the study, an automated search over a database did this. In a chat, you'll have to decide yourself which past conversation is relevant to the new task — the model won't do it for you.

07

Resources

Yifei Li, Heng Wang, Lingling Zhang et al. (Xi'an Jiaotong University), "Beyond Retrieval: Query-Conditioned Reuse of Long-Horizon Agent Trajectories." Tested on the agent benchmarks WebArena, WorkArena, AppWorld.

Research digest

Key result

The paradox: the longer the past conversation you paste into the prompt, the worse the new result. The model starts dragging in the old client's name, the old date, the old order number — as if they were the answer for the new task. The QCR method lets you reuse a successful past case (a negotiation, an email, a report) for a similar new task without the risk of the model accidentally copying someone else's data. Instead of the whole history, the model compresses it into a 4-field note: what to do the same way, which values to re-check, when the template doesn't fit, how to verify the result.

Principle

Workflow — the rule of action — is separated from bindings — the specific numbers and names. The rule stays; the numbers get flagged as "find out again." The model works with the note, not the raw text — and it physically has no old numbers at hand to copy.

Why it works

In a long context, every detail looks equally important to the model. The old client's name and the old start date are just as much "data at hand" as everything else, and the model grabs them as a ready-made answer. The 4-field note takes those numbers out of sight — next to them it says "find out again," and there's nothing left to copy.

When to apply

Text work → repetitive but not identical tasks: negotiating with a new candidate, an email to a new client, a report on a new project. Especially useful if you used to paste the old chat in full and the model mixed up old data with new. Not suitable when the new task needs different solution logic, not just different details.

Mini recipe

1. Find a past case: a successful example of a similar task — a thread, an email, a report. 2. Break it into 4 parts in a separate request: workflow (what's unchanging), bindings (which numbers and names to re-check), applicability (when the approach won't work), verification (how to check success). 3. Get a short note: it should be noticeably shorter than the original text, with no quotes from the old thread. 4. Plug it into the new task: give the model the note + a description of the new situation, and ask it to solve without looking back at the old values.

Examples

[BAD]: `Here's my thread with Jake about hiring him at $95k starting March 1 — negotiate the same way with the new candidate, Ryan` [GOOD]: `Break the Jake case into 4 parts: workflow (what to do the same way), bindings (salary, start date, relocation — find out again for Ryan), applicability (when the approach won't work), verification (how to check success). Give me a short note without quoting the thread`

In plain words

Here's the deal: a model's memory works like a goldfish with a straight-A-student complex — show it an example of an old task and it latches onto the details with a death grip. Instead of learning the principle, the model starts mindlessly copying old dates, names and prices into the new context. The QCR (Query-Conditioned Reuse) method fixes this bug by making the AI not just recall the past but put it through a strict audit, turning bulky experience into a compact, safe set of instructions.

It's as if you were teaching a friend to make chili from your old notes, which say: "At 2:15 pm added 300 grams of beef from farmer Bob". Instead of copying that nonsense word for word, you give them a template: "Brown the meat first, timing depends on the weight, and forget the farmer's name entirely — any decent one will do." Technically you're using old experience, but you throw out all the junk that could trip up a beginner.

To make this work, the model packs past experience into four concrete blocks. First it isolates the unchanging action template (the algorithm), then flags the variable values that need re-checking (dates, amounts, names), spells out stop signals for when this experience doesn't apply at all, and adds a verification checklist for the end result. Instead of a wall of text full of irrelevant numbers, you get a clear guide where 100% of the information is useful for the task at hand.

It was tested on complex agent action chains, but the principle is universal for any LLM work with repetitive processes. Hiring, writing code from a sample, or legal consultations — anywhere old details can "poison" a new result. QCR turns the model from a mindless imitator into a seasoned pro who remembers the essence but doesn't mix up yesterday's client with today's.

Bottom line: stop feeding the model raw logs of past wins — it drowns in them and starts hallucinating old data. You need to bring in experience filtering via QCR to keep only the "skeleton" of the solution. It's the only way to make agents work reliably over long stretches; otherwise they'll keep offering new customers discounts that expired last year.

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 QCR (Query-Conditioned Reuse): Extracting an Action Template from Past Experience Instead of Copying the Whole History arXiv:2608.12847

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

Related techniques

Few-Shot Prompting