Apply to my task
arXiv:2511.15755 ★ 74 Nov 19, 2025

Sequential Decomposition: One Complex Prompt → Three Simple Ones

Key result

Ask an LLM to do several things at once and you get filler like 'check the logs' or 'review the changes'. The study showed that 98.3% of answers to a single comprehensive prompt were this vague. Sequential decomposition fixes it: you split one complex prompt into a chain of three simple ones. Each does one thing; the output of the first goes into the second, and the second into the third. The model stops spreading its attention across several tasks, and you get concrete actions instead of generic phrases.

Sequential Decomposition: One Complex Prompt → Three Simple Ones

Sequential Decomposition: One Complex Prompt → Three Simple Ones

02

TL;DR

Sequential decomposition is a technique that replaces one complex prompt with a chain of simple ones. Instead of "analyze the problem, propose solutions and assess the risks", you make three separate requests: diagnosis → action plan → risk assessment. Each one receives the output of the one before it.

The key finding: When you ask an LLM to do several things at once, you get vague answers like "check the logs" or "review recent changes". In the study, a single comprehensive prompt produced answers like that 98.3% of the time. The reason: the model tries to satisfy several competing requirements in one answer and spreads its attention thin.

The gist of the method: Break the task into sequential steps. Each prompt does one thing. You plug the output of the first into the second, and the output of the second into the third. What comes out is concrete, actionable recommendations instead of generic phrases.

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.

03

Method Blueprint

STEP 1: Diagnosis → cause of the problem
         ↓ (output is passed along)
STEP 2: Planning → concrete actions  
         ↓ (output is passed along)
STEP 3: Risk assessment → what could go wrong
         ↓
FINAL: A structured plan with rationale

All three steps happen in a single chat, one after another. No code or API needed.

04

Example in Practice

Task: A Google Ads search campaign isn't producing leads: the budget gets spent, but there are no conversions. You need to find the cause and a plan to fix it.

Prompt 1 (diagnosis):

You are a diagnostics specialist. Analyze the situation and identify the root cause:

Google Ads search campaign:
- Budget: $1,500/month, 100% spent
- CTR: 2.1% (normal for the niche)
- Impressions: 45,000/month
- Clicks: 945
- Leads: 3
- Site conversion rate: 0.3%

Landing page: outsourced bookkeeping for freelancers and sole proprietors
Changes this month: new design for the lead form

What is the root cause of the missing leads?

Prompt 2 (planning):

You are an action-planning specialist. Here is the root cause:

[paste the output of prompt 1, for example: "The new lead form requires 7 fields instead of 3, and conversion dropped because of the friction"]

Create a step-by-step fix plan with:
- Concrete actions (what exactly to change)
- Success metrics (which numbers to track)
- Timelines (when to expect results)

Be specific: name the elements, values and tools.

Prompt 3 (risk assessment):

You are a risk assessment specialist. Assess the risks of these actions:

[paste the output of prompt 2, the action plan]

Context:
- Peak demand season (March-April, tax filing deadline)
- The lead form collects data for the CRM
- Competitors are advertising aggressively

What are the risks of each action? How can they be reduced?

Result: After three prompts you get: a specific cause (not "something's wrong with the site" but "the lead form has X fields, it needs Y"), a plan with measurable steps, and a risk assessment with mitigations. Each block will be detailed because the model was focused on a single task.

05

Why It Works

The LLM weakness: When one prompt contains several tasks, the model tries to please all of them at once. The result is a compromise where every part comes out shallow. The study showed that with comprehensive prompts the model produces 80 times less specific recommendations.

The LLM strength: Models handle narrow, well-defined tasks extremely well. A short focused prompt (50-100 tokens) delivers better results than a long multi-task one (200+ tokens).

How the method exploits this: We break a complex task into a chain of simple ones. Each prompt has one goal. Context is passed along through the outputs: the second prompt knows the first one's conclusions, the third knows the second one's. This creates progressive deepening instead of parallel dilution.

Control knobs:

  • Number of steps → 2 for simple tasks, 4-5 for complex ones
  • Agent roles → replace "diagnostics specialist" with concrete expertise ("financial auditor", "UX researcher")
  • Output format → add "as a checklist" or "with priorities" for more structure
06

Prompt Template

Step 1: Diagnosis

You are a diagnostics specialist. Analyze the situation and identify the root cause:

{problem description with concrete data}

What is the root cause?

Step 2: Planning

You are a planning specialist. Here is the root cause:

{output of step 1}

Create a step-by-step action plan with:
- Concrete actions
- Success metrics
- Timelines

Be specific: name {exactly what needs naming for your task}.

Step 3: Assessment

You are a risk assessment specialist. Assess the risks of these actions:

{output of step 2}

Context:
{constraints, deadlines, specifics of the situation}

What are the risks? How can they be reduced?

Placeholders:

  • {problem description}: symptoms, metrics, what changed
  • {output of step N}: copy the model's answer from the previous prompt
  • {context}: constraints, deadlines, what can't be changed
07

Limitations

⚠️ More time: Three prompts instead of one = three waits for a response. That can matter for urgent tasks.

⚠️ Manual context passing: You have to copy outputs between prompts. In long chains that gets tedious.

⚠️ Not for simple tasks: If one prompt handles the task well, decomposition is overkill. Use it for complex problems with several dimensions.

⚠️ Errors compound: If the first step produces a wrong diagnosis, the whole chain heads down the wrong path. Check the intermediate results.

08

How They Tested It

The study ran 348 controlled trials on the same scenario: an incident with an authentication service. Three approaches were compared: manual dashboard analysis (baseline), one comprehensive prompt (single-agent), and a chain of three specialized prompts (multi-agent).

They used a small model, TinyLlama (1B parameters), on purpose, so the results would be reproducible on ordinary hardware. Importantly, all the "agents" are the same model, just with different prompts. No magic, no different APIs.

They measured three things: validity (can it actually be executed technically), specificity (are there concrete commands, versions, parameters), and correctness (how closely it matches the right solution).

The results stunned the researchers: at the same speed (~40 seconds), the prompt chain produced recommendations that were 80 times more specific and 140 times more correct. On top of that, the chain showed zero variance: consistently identical quality across all 116 trials. The single agent was all over the place: occasionally it produced something meaningful (1.7% of cases), usually just generic phrases.

The main insight: the value isn't speed, it's determinism. When you can guarantee quality, you can use it in production.

09

Original Prompt from the Paper

Context: Three sequential prompts for analyzing an incident with an authentication service.

Agent 1 (Diagnosis Specialist):

You are a diagnostic specialist. Analyze the following telemetry and identify the root cause of the incident:

Service: auth-service v2.4.0
Error rate: 45% on /api/v1/login
Database: 85% connection pool utilization
Recent deployment: v2.4.0 at 14:23 UTC

What is the root cause?

Agent 2 (Remediation Planner):

You are a remediation planner. Given this root cause:

[Agent 1 output: "Database connection pool exhaustion due to connection leak in v2.4.0"]

Create step-by-step remediation actions with:
- Specific commands (e.g., kubectl, systemctl)
- Version numbers
- Configuration parameters

Be concrete and actionable.

Agent 3 (Risk Assessor):

You are a risk assessor. Evaluate the risks of these proposed actions:

[Agent 2 output: "1. Rollback auth-service to v2.3.0 using kubectl rollout undo..."]

Context:
- Production environment
- Peak traffic hours
- Previous stable version: v2.3.0 (deployed 48h ago)

Assess risks and suggest mitigations.
10

Adaptations and Extrapolations

💡 Adapting it for business decisions

The same structure works for strategic decisions, not just technical incidents:

Step 1: Analysis

You are a business analyst. Analyze the situation:

Online store selling kids' products, Denver
- Revenue: $85,000/month, down 15% over the quarter
- Average order value: $64 (was $76)
- Repeat purchases: 12% (was 18%)
- Changes: launched a loyalty program 3 months ago

What is the root cause of the decline?

Step 2: Solutions

You are a strategist. Here is the cause: {output of step 1}

Propose 3 solutions with:
- Concrete actions
- Expected impact in dollars
- Implementation timeline

Step 3: Risks

You are a risk manager. Assess the risks: {output of step 2}

Context: the budget for changes is $8,000, and peak season starts in 2 months.

🔧 Technique: add an "antagonist role"

Between planning and risk assessment you can insert a fourth step, a critique of the plan:

You are a skeptic looking for weak spots. Here is the plan: {plan}

Find the 3 biggest problems with this plan. Why might it fail?

Pass the critique into the final step, and the plan becomes more resilient to real-world obstacles.

11

Resources

  • Paper: "Multi-Agent LLM Orchestration Achieves Deterministic, High-Quality Decision Support for Incident Response"
  • Author: Philip Drammeh, independent researcher
  • Code and data: github.com/Phildram1/myantfarm-ai
  • Related work: ChatDev (multi-agent systems for software development), Site Reliability Engineering by Google

Research digest

Key result

Ask an LLM to do several things at once and you get filler like 'check the logs' or 'review the changes'. The study showed that 98.3% of answers to a single comprehensive prompt were this vague. Sequential decomposition fixes it: you split one complex prompt into a chain of three simple ones. Each does one thing; the output of the first goes into the second, and the second into the third. The model stops spreading its attention across several tasks, and you get concrete actions instead of generic phrases.

Principle

You break the task into three steps. The first prompt diagnoses the cause. You copy the answer and plug it into the second, which plans the actions. Copy again and plug it into the third, which assesses the risks. Each prompt knows only its own role and the previous output, which creates progressive deepening instead of parallel dilution. Everything happens in one chat, in sequence. No code or API needed.

Why it works

LLMs handle multitasking in a single prompt poorly. When there are several tasks, the model tries to please all of them at once and every part comes out shallow. The numbers from the study: with a comprehensive prompt, recommendations are 80 times less specific. A short focused prompt (50-100 tokens) gives better results than a long multi-task one (200+ tokens). Decomposition takes advantage of this: each step has a narrow focus, and context is passed along through the outputs.

When to apply

For complex problems with several dimensions: product incident post-mortems, analyzing failed launches, strategic decisions with risks. Especially when a single prompt gives you generic phrases instead of specifics. NOT a fit for simple tasks where one prompt already gives a good result; it just adds complexity. Also not for urgent situations, since three prompts take more time.

Mini recipe

1. First prompt, diagnosis: Role 'diagnostics specialist', task: find the root cause. Give the symptoms, metrics and what changed. 2. Second prompt, plan: Role 'planning specialist', paste in the first output. Ask for concrete actions, success metrics and timelines. Add 'Be specific: name the elements, values and tools'. 3. Third prompt, risks: Role 'assessment specialist', paste in the second output. Add context (constraints, deadlines) and ask for the risks and how to reduce them.

Examples

[BAD]: `The ad campaign isn't producing leads and the $1.5k budget is being wasted. Analyze the cause, propose an action plan and assess the risks`: you'll get generic phrases like 'check your targeting settings' and 'optimize your creatives'. [GOOD]: Three prompts in sequence: 1) `You are a diagnostics specialist. Search ads: budget $1.5k, CTR 2.1%, 945 clicks, 3 leads, site conversion 0.3%. A month ago we redesigned the form. What is the root cause of the missing leads?` 2) Got 'the form requires 7 fields instead of 3' → `You are a planning specialist. Root cause: [pasted answer]. Create a plan: concrete actions, metrics, timelines` 3) Got the plan → `You are a risk specialist. Assess the risks of the plan: [pasted answer]. Context: peak demand season, the form feeds the CRM` The result is a specific cause (not 'something's wrong with the site' but 'the form has 7 fields, it needs 3'), measurable steps and a risk assessment. Each block is detailed because the model focused on one task.

In plain words

The thing is, today's models aren't all-powerful oracles; they're more like very eager but scatterbrained interns. When you dump one giant task with a pile of conditions on an LLM, the model starts to drift and spits out watery nonsense. It tries to juggle everything at once: the diagnosis, the plan and the risks, and as a result its attention gets diluted and you get a shallow answer. Sequential decomposition tackles the problem head-on: we simply forbid the model from thinking about everything at once and make it solve the tasks strictly one at a time.

It's like going to a doctor who tries to operate on you, write a prescription and fill out your insurance paperwork all at the same time. The odds of the scalpel getting left inside approach infinity. Instead, you go in stages: first only tests, then only the diagnosis, and only at the end the treatment. This study showed that if you break the process into a chain, the model produces results 80 times more specific than if you asked for everything at once in a single prompt.

It works as a strict assembly line: diagnosis, then planning, and finally risk assessment. In the first step the model digs only into the cause of the problem without getting distracted by advice. The output goes to the second stage, where the action plan takes shape, and only then does the third pass look for weak spots in that plan. Each step gets a "clean" context with no extra noise, so what comes out isn't a set of generic phrases but a deterministic, high-quality plan.

Although the method was tested on IT incidents, the principle is universal and applies to any complex task, whether it's launching a Google Ads campaign or a strategy for entering a new market. Wherever there's a "why, what to do, what are the risks" chain, one big prompt loses to three small ones. It turns reading tea leaves into a predictable business process where each stage checks the previous one, cutting out the model's hallucinations and laziness.

Bottom line: stop counting on the "magic" of one long request; that's the road to mediocrity and mistakes. Slice the task into pieces, use sequential decomposition and make the model work like an assembly line, not a half-baked philosopher. Either you build a clear request architecture, or you get 80 times less specificity than you could have. Your call.

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 Sequential Decomposition: One Complex Prompt → Three Simple Ones arXiv:2511.15755

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

Related techniques

Task Decomposition and Prompt Chaining

Get the week’s best papers by email

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

By subscribing you agree to our Privacy Policy. We only use your email to send the newsletter.