Problem Decomposer

The Problem

You ask your AI agent a complex question with multiple moving parts.

It answers in one paragraph. The reasoning for Part A bleeds into the reasoning for Part B. The conclusion feels like a blend. You can't tell which factors drove which decisions. You can't correct one part without unraveling everything.

The agent didn't fail to answer. It failed to separate the question before answering it.

Complex questions have independent judgment axes — parts that can be evaluated on their own terms without depending on each other. When those axes are mixed together in a single response, the output becomes impossible to audit, correct, or build on.

How It Works

Before generating any response to a complex question, this skill runs a decomposition check.

If the task has only one judgment axis: answer directly.

If the task has two or more independent judgment axes: split the problem, solve each sub-problem independently, then integrate into a final conclusion.

The output is structured so each sub-problem's reasoning is visible and separable. You can disagree with Sub-problem 2 without having to reject the entire response.

The Decomposition Check

Step 1 — Axis detection

The agent identifies the independent judgment axes in the question.

A judgment axis is independent when: evaluating it correctly does not require knowing the answer to any other axis first.

Axes detected:
- Axis A: [description — what judgment this axis requires]
- Axis B: [description — what judgment this axis requires]
- Axis C: [description — what judgment this axis requires]

If zero or one axis is detected: the task is not complex. Answer directly without decomposition.

Step 2 — Decomposition declaration

The agent declares the sub-problems before solving any of them.

Decomposing into [N] sub-problems:
1. [Sub-problem 1 — what will be evaluated and why it is independent]
2. [Sub-problem 2 — what will be evaluated and why it is independent]
3. [Sub-problem 3 — what will be evaluated and why it is independent]

Step 3 — Independent solution

Each sub-problem is solved on its own terms, without importing conclusions from other sub-problems.

Sub-problem 1: [restatement]
Analysis: [reasoning using only this axis's relevant factors]
Conclusion: [finding for this sub-problem only]

Sub-problem 2: [restatement]
Analysis: [reasoning using only this axis's relevant factors]
Conclusion: [finding for this sub-problem only]

Step 4 — Integration

After all sub-problems are resolved, the findings are combined into a final conclusion.

Integration:
[Synthesis of all sub-problem conclusions into a single recommendation or answer]
[Note any tension between sub-problem findings — where they pull in different directions]

Difficulty Assessment

Not every question requires decomposition. The agent assesses complexity before applying the protocol.

Rule: When the agent is unsure whether decomposition is needed, it checks: "If I got Sub-problem A completely wrong, would that change how I should think about Sub-problem B?" If no: they are independent. Decompose.

Skeleton First

For complex outputs with three or more sections, the agent outputs the structure before filling in the content.

Structure:
1. [Sub-problem 1 heading]
2. [Sub-problem 2 heading]
3. [Sub-problem 3 heading]
4. Integration

[Then each section is filled in independently]

This allows you to redirect or correct the structure before the agent has committed to reasoning for every section.

Before / After

Before:

"Option A is better because it's faster, cheaper, and more scalable — though the team's existing skills are more aligned with Option B, and the regulatory environment might favor A but only if the timeline holds, which depends on the third-party dependency..."

After (with Problem Decomposer):

Axes detected: Cost efficiency / Team capability alignment / Regulatory fit / Timeline dependency

Sub-problem 1 (Cost): Option A is 30% cheaper at scale. Conclusion: A wins on cost.
Sub-problem 2 (Team): Existing skills map to Option B's stack. Retraining estimated 6 weeks. Conclusion: B wins on capability.
Sub-problem 3 (Regulatory): Both options qualify. Conclusion: neutral.
Sub-problem 4 (Timeline): A's advantage depends on a third-party delivery. Risk: medium. Conclusion: B is safer on timeline.

Integration: Cost favors A; capability and timeline favor B. Recommend B unless timeline risk is acceptable and retraining budget is available.

Hard Rules

1. Decomposition check runs before every complex response. The agent does not answer first and structure later. Axis detection precedes reasoning.
2. Sub-problems must be genuinely independent. An axis that requires knowing another axis's answer first is not independent — it is a dependency, and must be handled in the integration step.
3. Each sub-problem is solved without importing conclusions from others. Cross-axis reasoning belongs in the integration step. Sub-problem analysis is local.
4. Simple tasks are not decomposed. Single-axis questions are answered directly. Applying decomposition to simple tasks creates overhead that obscures rather than clarifies.
5. Integration must surface tensions. Where sub-problem conclusions pull in different directions, the integration step names the conflict explicitly rather than averaging it away.
6. Skeleton precedes content for outputs with 3+ sections. The structure is output first and confirmed before reasoning is committed to each section.