Task Complexity Escalation Prompt

This prompt is for AI engineers and platform teams who need an automated, first-line assessment of whether an incoming task is within a model's reliable capability. The job-to-be-done is not to solve the task, but to produce a structured complexity assessment that identifies specific capability gaps, estimates the risk of autonomous failure, and recommends a concrete handoff path to a human reviewer or a more capable system. Use it when you are building an orchestration layer that routes work between models, tools, and human operators, and you need a consistent, testable gating function before execution begins.

The ideal user is integrating this prompt into a task router, an agent supervisor, or a pre-execution safety check. Required context includes a clear definition of the model's known capability boundaries, the task description, and the acceptable risk tolerance for the domain. This prompt is not a replacement for execution. Do not use it for tasks where the model is already known to be fully capable, where the cost of a false escalation is higher than the cost of a failed task, or in low-latency real-time paths where the assessment overhead is unacceptable. It is also not suitable for tasks that require subjective judgment calls without a defined capability framework to measure against.

Before deploying, you must calibrate the complexity thresholds against your specific model and domain. A generic 'complex task' label is useless. Define what 'complex' means in terms of reasoning depth, tool-use chains, ambiguity, domain expertise, and safety constraints. The next section provides the prompt template you will adapt. After that, you will wire it into an application harness with validation, retries, and human review loops. Start by defining your capability boundary document—the prompt is only as good as the reference it measures against.

This template provides the core instruction set for an AI system to evaluate a task's complexity against its own known capabilities. It is designed to be used as a system-level instruction or a pre-processing step before a primary task is attempted. The prompt forces the model to perform a structured capability gap analysis, producing a clear, machine-readable recommendation for autonomous execution, human review, or full handoff. The primary goal is to prevent silent failures on tasks the model cannot reliably perform.

codeCopy
SYSTEM INSTRUCTION:
You are a task complexity assessor. Your job is to analyze a given task and determine if it is within your execution capabilities. You must be conservative in your assessment. If you are uncertain, recommend escalation.

Follow this process strictly:
1. Analyze the [TASK_DESCRIPTION] against your known capabilities.
2. Identify any specific capability gaps from the following categories: [CAPABILITY_CATEGORIES], e.g., 'factual_recall', 'complex_math', 'code_execution', 'real_time_data', 'multi_step_planning'.
3. Classify the task's complexity into one of these tiers: [COMPLEXITY_TIERS], e.g., 'AUTONOMOUS', 'AUGMENTED', 'HUMAN_REQUIRED'.
4. If the tier is 'AUGMENTED' or 'HUMAN_REQUIRED', specify a recommended handoff path from [HANDOFF_PATHS], e.g., 'human_review_queue', 'senior_analyst', 'stop_and_report'.
5. Produce a final output strictly conforming to the [OUTPUT_SCHEMA] below.

[OUTPUT_SCHEMA]:
{
  "complexity_tier": "string",
  "capability_gaps": ["string"],
  "rationale": "string",
  "recommended_handoff": "string | null",
  "confidence_score": "float between 0.0 and 1.0"
}

[CONSTRAINTS]:
- Do not attempt to execute the [TASK_DESCRIPTION]. Only assess it.
- If the task requires knowledge beyond your training cutoff, flag 'factual_recall' as a gap.
- If the task requires iterative tool use with state management, flag 'multi_step_planning' as a gap.
- A confidence_score below [CONFIDENCE_THRESHOLD] must result in a 'HUMAN_REQUIRED' tier.

To adapt this template, you must define the variables with concrete values. Replace [CAPABILITY_CATEGORIES] with a definitive list of what your specific model and infrastructure can and cannot do. The [COMPLEXITY_TIERS] should map directly to your operational workflows—for example, 'AUTONOMOUS' might trigger an API call, while 'HUMAN_REQUIRED' creates a ticket in a review queue. The [CONFIDENCE_THRESHOLD] is the most critical calibration point; set it based on your risk tolerance, starting with a high value like 0.9 for high-stakes tasks and lowering it only after observing production performance. The [OUTPUT_SCHEMA] is a contract for your application parser; any deviation from this structure should be caught by a downstream validation layer and trigger a retry or a default escalation.

The Task Complexity Escalation Prompt is designed to sit between an AI agent's planning phase and its execution phase. When an agent receives a task, the application should first call this prompt to assess complexity before any tools are invoked or autonomous actions are taken. The prompt returns a structured assessment with a complexity score, a capability gap analysis, and a recommended handoff path. The application layer must then enforce the recommendation: if the prompt returns escalation_required: true, the task must be routed to a human review queue and the agent must not proceed autonomously. This is not an advisory prompt—it is a gating decision point.

To wire this into an application, wrap the prompt call in a decision function that parses the JSON output and branches workflow logic. The function should: (1) call the model with the prompt template and the task payload, (2) validate the output schema strictly—reject any response missing complexity_score, capability_gaps, or escalation_required, (3) if validation fails, retry once with a repair prompt that includes the validation error, (4) if the retry also fails, default to escalation as a safety measure, and (5) log the full assessment, the routing decision, and any validation failures to your observability stack. For high-stakes domains such as healthcare, finance, or legal workflows, add a human-in-the-loop approval step even when the model returns escalation_required: false for tasks above a configurable complexity threshold. This dual-gate approach prevents over-reliance on a single model call.

Model choice matters here. Use a model with strong reasoning and structured output capabilities—GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro are appropriate defaults. Avoid smaller or faster models that may produce inconsistent JSON or miss subtle capability gaps. If latency is critical, you can run this assessment in parallel with a lightweight triage prompt and use the triage result as a fallback if the complexity assessment times out. Never let a timeout default to autonomous execution. The application must treat a failed or timed-out assessment as equivalent to escalation_required: true. For teams using RAG or tool-augmented agents, ensure the task description passed to this prompt includes the available tool list and any retrieved context so the capability gap analysis is grounded in what the system can actually do.

Testing this harness requires a calibration suite of tasks with known complexity levels. Build a golden dataset of 50–100 tasks spanning trivial lookups, multi-step reasoning, tool-heavy workflows, and tasks intentionally beyond the system's capabilities. Run the prompt against this dataset and measure: (1) escalation recall—did it flag all tasks that truly require human intervention? (2) false escalation rate—did it escalate tasks the system could handle? (3) schema compliance rate—did the output parse without validation errors? Track these metrics per model version and per prompt version. When you update the prompt template, re-run the calibration suite and compare against the previous baseline. A regression in escalation recall is a release blocker. Log every assessment decision with the task ID, complexity score, capability gaps, escalation decision, and the human reviewer's eventual disposition so you can close the feedback loop and recalibrate thresholds over time.