VPS (Verbal Process Supervision): Step-by-Step Critique from a Strong Model Squeezes Accuracy Out of a Weak One

⚠️ Where the method shines: complex analytical tasks with a chain of reasoning — business analysis, legal argumentation, strategic decisions. NOT for creative tasks with subjective criteria. NOT for code.

Task: A founder is preparing the pricing rationale for a new SaaS product. The logic needs a check before pitching investors at Y Combinator Demo Day.

Prompt:

You are a SaaS pricing expert with experience in B2B startups.

=== TASK ===
Here is the pricing rationale for my product:

"We charge $299/month for the business plan. Competitors charge 
$149–$249. We're more expensive because we have better UX and integrations 
with QuickBooks. The target customer is companies with 50–200 employees. So 
per employee that's $1.50–$6/month — cheaper than the office coffee machine."

=== MODE 1: ACTOR ===
First — expand this rationale into 5–7 clear steps 
of a logical chain. Number each step and phrase it 
as a separate argument.

=== MODE 2: CRITIC ===
Then — switch to critic mode. Go through each 
step separately:
- What is logically sound in this step?
- What's the weak spot or assumption?
- What counterargument will an investor raise?

=== MODE 3: ACTOR (REFINED) ===
Rewrite the rationale based on the critique. Keep the strong steps, 
strengthen the weak ones, replace the vulnerable arguments.

Then act as the critic again for the new version. Repeat the cycle 
once more if at least one serious vulnerability remains.

Result:

The model will lay out a numbered chain of arguments (step 1), then break down each step and point out its weak spot — for example, "the coffee-machine comparison appeals to cost, not to value." Then it rewrites the rationale. In the second round the critique gets sharper and the vulnerabilities fewer. The final answer will hold up against standard investor questions.

A model is good at generating text from context but bad at tracking errors in a long chain of reasoning. After 3–4 steps it loses the thread: the final answer sounds convincing but contains an error somewhere in the middle. Ask it to "check" — and it checks the result, not the path to it.

Critiquing each step works because it breaks one big task ("find the error in the reasoning") into small ones ("evaluate this particular step"). The model handles local evaluation well — it sees the step in the context of the problem's conditions and the preceding steps.

Iteration amplifies the effect: the first round removes the gross errors, the following ones the subtle ones. It's like editing a text: the first pass catches typos, the second fixes the logic, the third polishes the tone.

Control levers: - Number of rounds → 2 rounds for most tasks, 4 for complex ones. More than 4 risks "over-editing" - Critic strictness → add "be as tough as possible, like a skeptical investor" — sharper critique - Step format → "no more than 7 steps" → more compact, less blur - Stopping condition → "stop when no step draws an objection" → adaptive

You are an expert in {domain}.

=== TASK ===
{task description or text to analyze}

=== MODE 1: ACTOR ===
Solve the task step by step. Number each step of the reasoning. 
Each step is a separate thought or argument, no more than 3 sentences.

=== MODE 2: CRITIC ===
Go through each step separately:
- What is right in this step?
- What's the weak spot or vulnerable assumption?
- What needs to be fixed?

=== MODE 3: ACTOR (REFINED) ===
Rewrite the solution based on the critique. State what changed and why.

Repeat MODE 2 and MODE 3 {number_of_rounds — I recommend 2} more times.
Stop the cycle if the critic finds no substantial issues.

Placeholders: - {domain} → "financial analysis," "marketing strategy," "legal argumentation" - {task description} → your task, text, plan, or decision to check - {number_of_rounds} → 2 for ordinary tasks, 3–4 for complex, high-stakes ones

🚀 Quick start — paste into the chat:

Here is the template for the VPS method (step-by-step critique). Adapt it to my task: 
[describe your task in 1–2 sentences].
Ask me questions about the placeholders to fill in the template.

[paste the template above]

The LLM will ask about the domain and the specifics of your task — because without them it won't know what standards of critique to apply or what benchmark to check the steps against.

⚠️ A weak critic sinks a strong actor: If the critic model is weaker than or on par with the solver, VPS hurts — accuracy drops below the starting point. In practice: don't ask a weak free model to critique a strong paid model's answers. Do it the other way around.

⚠️ Code is the exception: Errors in code often show up only at runtime ("crashed with error X"). Verbal critique of steps won't catch runtime errors — only logical ones. Code needs a different technique.

⚠️ More rounds ≠ better result: The optimal number of rounds is unpredictable and depends on the task. Sometimes 2 rounds beat 4 — the model starts "over-editing" things that were right. Add a condition: "stop if there are no remarks."

⚠️ Subjective tasks don't work: A critique like "is this slogan catchy or not?" gives no clear criterion for revision. VPS works where a step can be objectively right.

The team took two kinds of model pairs: same-family models (GPT-5.4 High vs. Low — one model at different power settings) and cross-architecture pairs (GLM vs. Nemotron, Gemma 4 vs. GPT-OSS). They tested on three different task types: graduate-level science questions (GPQA Diamond), competition math (AIME 2025), and competitive programming (LiveCodeBench).

The key move was equalizing compute across methods. Otherwise it's unclear: did VPS win because it's better, or just because it used more tokens? They compared it with two competitors at the same budget: Self-Consistency (5 parallel solutions + majority vote) and Reflexion (the same idea of critique, but of the final answer only). That's where the main insight surfaced: Reflexion with the same critic model lost to VPS by 8–12 points — meaning it's not the critique itself that matters, but its granularity.

An unexpected finding: Reflexion worsened the strong actor's result on GPQA (92.8% → 86.4%), while VPS sidestepped that problem. This explains a real user experience: "I asked it to check the answer and it got worse" — because the model received a general signal with no information about the specific error.

The VPS algorithm from the paper:

Require: Input x, actor πθ, supervisor C, maximum rounds R
Ensure: Refined trajectory τ* and final answer y*

1: τ₀ ~ πθ(· | x)
2: for r = 0, 1, ..., R − 1 do
3:   cr ← C(τr, x)
4:   if Stop(τr, cr) then
5:     return τr, ExtractAnswer(τr)
6:   end if
7:   τr+1 ~ πθ(· | x, τr, cr)
8: end for
9: return τR, ExtractAnswer(τR)

Context: A formal description of the generate–critique–refine loop. τ is the reasoning trajectory (the solution steps), C is the critic model, cr is the verbal critique in round r. In each round, the actor generates a new solution taking into account the original task x, the previous solution τr, and the critique cr.

💡 Adaptation: an asymmetric critic via different chats

The method is at full power when the critic is stronger than the actor. A way to do it without an API:

1. In ChatGPT (GPT-4o), write the task and ask it to solve it step by step
2. Copy the solution into Claude 3.5 Sonnet or o1 and ask "go through each step: where's the weak spot?"
3. Copy the critique back and ask it to rewrite

Clunky, but it faithfully reproduces the original mechanics. Especially valuable for high-stakes decisions: legal documents, financial models, strategy documents.

🔧 Technique: a named critic → sharper critique

Faceless critic:

Switch to critic mode...

Named critic:

Now you are Magnus Carlsen analyzing a chess game. 
You don't tolerate a single inaccurate move. Go through every step 
of my plan with his ruthlessness.

Or in a business context: "You are Mark Cuban (Shark Tank), picking apart someone else's business model before investing." A specific character switches on a particular style of thinking and makes the critique concrete rather than generic.

🔧 Technique: visible reasoning steps

Add this to the prompt by default:

After each round of critique, output: 
"Steps changed: [list]" and "Reason for change: [explanation]"

This shows exactly what changed between iterations — and helps you tell when to stop and when to run another round.

🔀 Extrapolation: VPS + Chain-of-Thought for negotiations

A combination with structured thinking to prepare for tough negotiations:

You are an experienced negotiator.

TASK: I'm negotiating with a supplier for a 15% price cut. 
My current arguments: [your arguments]

MODE 1 — ACTOR:
Break my negotiation strategy into 6 steps: 
opening, anchoring, concessions, BATNA, emotional moment, close.
For each step — a specific line or action.

MODE 2 — CRITIC (you are the supplier):
Take the supplier's side. Respond to each of my steps: 
"At step X I'll answer like this... because..."

MODE 3 — ACTOR (REFINED):
Rework the strategy to account for the supplier's counterarguments.

Repeat the cycle once more.

Here the critic doesn't "look for errors" but simulates a real opponent — which turns VPS into a tool for preparing for negotiations, pitches, and presentations.

Paper: Process Supervision via Verbal Critique Improves Reasoning in Large Language Models

Author: Hao-Yuan (Mark) Chen, Mindify AI Research / University of London

Key references: - Reflexion (Shinn et al., 2023) — the baseline verbal RL method that VPS outperforms - Self-Consistency (Wang et al., 2023) — parallel sampling + voting - Let's Verify Step by Step (Lightman et al., 2023) — step-by-step verification