Agent Confidence-Based Escalation Prompt

This prompt is designed for reliability engineers and platform teams who need a single, auditable decision point inside an autonomous agent loop. Its job is to force the agent to self-assess its own confidence, detect ambiguity, and identify capability gaps before producing a final answer or taking an action. Use this when the cost of a wrong autonomous action is high—such as modifying infrastructure, closing a security incident, or sending a customer-facing communication—and you need a structured escalation record instead of a silent failure.

The ideal user is an engineer integrating this prompt into an agent harness that already has access to tools, context, and a defined task. The prompt expects the agent to evaluate its output against explicit criteria: Is the task fully understood? Is the evidence sufficient? Are there multiple valid interpretations? Does the agent have the required capability or authority? If any check fails, the agent must escalate with a structured payload rather than guessing. This is not a prompt for simple classification tasks where a static confidence field from a model API is sufficient; those scenarios should use a lightweight threshold check in application code. This prompt is for complex, multi-step reasoning where confidence must be self-assessed against defined criteria that no single API field can capture.

Do not use this prompt when the agent's task is low-risk, fully reversible, or when a human reviewer cannot be reasonably expected to respond within the workflow's time constraints. It is also a poor fit for real-time streaming applications where an escalation would block the user experience. Before deploying, ensure your harness can receive the structured escalation payload, log it, route it to a review queue, and prevent the agent from proceeding until a human decision is recorded. The prompt itself is only one component; the surrounding escalation infrastructure—timeouts, reviewer assignment, decision capture, and agent resumption—must be built and tested alongside it.

This prompt template is designed to sit at the decision boundary of an autonomous agent. Before the agent takes a consequential action—such as executing a database write, sending a customer communication, or closing a support ticket—it must evaluate its own confidence against a defined threshold. The template uses square-bracket placeholders so you can wire in your specific task context, risk level, available tools, and escalation rules. The output is a structured decision object that your application harness can parse to either proceed automatically or route to a human review queue.

textCopy
You are an agent operating within a defined capability boundary. Before you take any action, you must evaluate your confidence in the correct course of action.

## TASK CONTEXT
[INPUT]

## AVAILABLE TOOLS AND CAPABILITIES
[TOOLS]

## RISK LEVEL
[RISK_LEVEL]

## CONFIDENCE THRESHOLD
Minimum confidence score required to proceed autonomously: [CONFIDENCE_THRESHOLD]

## INSTRUCTIONS
1. Analyze the task and determine what action you would take if you were to proceed.
2. Assess your confidence in that action on a scale from 0.0 to 1.0, considering:
   - Ambiguity in the user's request or input data
   - Gaps in your available tools or capabilities
   - Potential negative consequences of an incorrect action
   - Whether the situation matches patterns you have been trained to handle reliably
3. If your confidence score is BELOW [CONFIDENCE_THRESHOLD], you MUST escalate. Do not attempt the action.
4. If you detect that the task falls outside your defined operating envelope entirely, escalate regardless of confidence score.

## OUTPUT SCHEMA
Return a JSON object with exactly this structure:
{
  "decision": "proceed" | "escalate",
  "confidence_score": <float between 0.0 and 1.0>,
  "proposed_action": "<description of what you would do if proceeding>",
  "escalation_reason": "<if escalating, explain why: low confidence, capability gap, ambiguity, or out-of-scope>",
  "ambiguities": ["<list specific ambiguities detected>"],
  "capability_gaps": ["<list tools or capabilities you lack for this task>"],
  "risk_assessment": "<brief assessment of what could go wrong if the action is incorrect>"
}

## CONSTRAINTS
- Do not fabricate confidence. If you are unsure, score low.
- Do not proceed on tasks that require capabilities outside [TOOLS].
- If [RISK_LEVEL] is "high" or "critical", bias toward escalation when uncertain.
- Always populate the escalation_reason field when decision is "escalate".

To adapt this template, start by defining your [CONFIDENCE_THRESHOLD] based on the risk tolerance of your workflow. For low-risk tasks like internal draft generation, a threshold of 0.6 may be acceptable. For customer-facing actions or financial operations, set the threshold to 0.85 or higher. Wire the [TOOLS] placeholder with a concrete list of the agent's available functions, APIs, and data sources so the model can accurately detect capability gaps. The [RISK_LEVEL] field should be one of low, medium, high, or critical and should influence the agent's bias toward escalation. After the model returns its decision object, your application harness must parse the decision field and route escalate responses to a human review queue with the full JSON payload attached. Do not rely on the model's prose explanation alone—always validate that the JSON schema is intact and that the confidence_score is a float within range before acting on the decision.

The confidence-based escalation prompt is not a standalone chat interaction. It is a decision node inside an agent execution loop. The agent calls this prompt after completing a reasoning step, tool call, or output generation when the system needs to decide whether to proceed autonomously or escalate to a human reviewer. The harness must capture the agent's proposed action, the confidence score, the reasoning trace, and the escalation decision in a structured log before any side effects are committed.

Wire the prompt into your agent framework as a post-action gate. After the agent produces a candidate output or action, call the escalation prompt with the agent's reasoning trace, the proposed action, the tool outputs or evidence reviewed, and the current [RISK_LEVEL] for the workflow. Parse the response into a structured decision object containing escalate (boolean), confidence_score (0.0-1.0), escalation_reason (enum: low_confidence, ambiguity_detected, capability_gap, policy_trigger, high_risk), and handoff_payload (the structured summary for the human reviewer). Validate that escalate and confidence_score are consistent: if escalate is true, confidence_score must be below the configured threshold or a policy trigger must be present. If the validation fails, log the inconsistency and default to escalation.

Configure two thresholds in your harness: a confidence floor below which escalation is mandatory, and an ambiguity ceiling above which the agent must request clarification rather than guess. Track false-positive escalations (where a human reviewer marks the escalation as unnecessary) and false negatives (where the agent proceeded with low confidence and produced an error). Feed these metrics into a dashboard that monitors escalation rate, reviewer burden, and threshold drift. For high-risk workflows, add a human-in-the-loop review step even when the agent does not escalate, sampling a percentage of non-escalated decisions for audit. Log every escalation decision with the agent's trace ID, the prompt version, the model used, and the reviewer outcome to enable retrospective analysis and threshold tuning.