명확한 에스컬레이션 조건
명시적 요청, 정책 공백, 진행 없음 및 임계값을 다룹니다
명확한 에스컬레이션 조건은(는) CoddyKit의 무료 Claude Architect 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Claude Architect 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Claude Architect 강의에는 총 4개의 강의가 포함되어 있습니다.
이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.
Why Escalation Triggers Matter
An autonomous Claude agent will eventually hit a wall it cannot or should not cross alone. The question isn't whether to escalate to a human, but when — and that decision must be defined by clear, deterministic triggers, not vibes.
In the Customer Support scenario, a refund agent that escalates too late frustrates users; one that escalates on every hiccup destroys its own value. This lesson nails down the four reliable escalation triggers the exam expects you to recognize:
- An explicit human request
- A policy gap (no rule covers the case)
- No progress after genuine attempts
- A threshold violation
Trigger 1: Explicit Human Request
If a customer asks to speak to a human, that is not a signal to interpret — it is an instruction to obey. Escalate immediately.
Do not try to talk the user out of it, re-route them through more self-service, or run sentiment analysis to decide if they 'really' meant it. A direct request for a person is the single most unambiguous trigger you will ever get. Treat it as a hard, deterministic branch in your control flow.
# Detect an explicit handoff request as a deterministic branch
def should_escalate(user_message: str) -> bool:
handoff_phrases = [
"talk to a human", "speak to an agent",
"real person", "transfer me",
]
text = user_message.lower()
return any(p in text for p in handoff_phrases)
if should_escalate(latest_user_message):
escalate_to_human(reason="explicit_request", transcript=history)Trigger 2: Policy Gaps
A policy gap occurs when the agent faces a case that no documented rule covers. Example: a refund request for a product category your refund policy never mentions, or an edge case the system prompt simply doesn't address.
The wrong move is to improvise a decision — the model will confidently invent a policy that may be wrong, costly, or non-compliant. The right move is to recognize the absence of guidance and hand off to a human who can make (and document) the call.
SYSTEM_PROMPT = """You are a support agent.
Apply ONLY the refund rules in <policy>.
If a request falls outside every rule in <policy> —
for example a product category or scenario not listed —
do NOT invent a decision. Call escalate_to_human with
reason='policy_gap' and summarize what the policy did not cover.
"""Trigger 3: No Progress After Attempts
The agent should genuinely try before giving up. But once it has made real attempts — gathered identifiers, looked up orders, proposed solutions — and still cannot resolve the issue, lack of progress is itself a valid escalation trigger.
Note the distinction from a blind iteration cap. We escalate because the agent has demonstrably stalled on the task, not merely because a loop counter ticked over. The attempts must be real and observable, not a single failed call dressed up as 'no progress.'
# 'No progress' = real attempts made, issue still unresolved
attempts = 0
resolved = False
while not resolved and attempts < MAX_ATTEMPTS:
result = agent_step(history) # real work each turn
resolved = result.issue_resolved
attempts += 1
if not resolved:
escalate_to_human(
reason="no_progress",
attempts=attempts,
partial_results=result.partial,
)Trigger 4: Threshold Violations
Some actions exceed what an automated agent is permitted to do. A refund above a dollar limit, a bulk operation over a size cap, or any value crossing a defined boundary is a threshold violation — and a clean escalation trigger.
Thresholds are objective and auditable: the value either crosses the line or it does not. That makes them perfect candidates for deterministic enforcement rather than polite prompt instructions, as we'll see in the next scene.
Enforce High-Stakes Thresholds with Hooks
For a threshold with financial, legal, or safety consequences, a prompt is not enough. Prompts are ~90% probabilistic; a determined or unlucky path can still slip past a soft instruction.
Use a PostToolUse / outgoing-call hook to block the action deterministically. The classic exam example: a hook that blocks any process_refund over $500 and forces escalation. Hooks give you 100% deterministic enforcement — the right tool when failure is expensive.
# Outgoing-call hook: deterministic threshold enforcement
def on_process_refund(call):
if call.input["amount"] > 500:
return {
"block": True,
"redirect": "escalate_to_human",
"reason": "threshold_violation: refund > $500",
}
return {"block": False}BAD Triggers: What NOT to Escalate On
Just as important as the good triggers are the ones the exam flags as anti-patterns. Do not drive escalation from:
- Sentiment analysis — 'the user sounds angry' is noisy and gameable.
- Model self-rated confidence (e.g. 'I'm 6/10 sure') — LLM confidence scores are unreliable and uncalibrated.
- Untrained classifiers — an ad-hoc 'is this hard?' model you never validated.
These produce inconsistent, unauditable behavior. Stick to the four objective triggers: explicit request, policy gap, no progress, threshold violation.
The Emotion Pattern: Acknowledge, Solve, Then Escalate
An upset customer is not, by itself, an escalation trigger. The recommended pattern is: acknowledge the emotion → propose a concrete solution → escalate only if the request is reiterated.
This avoids two failures: coldly ignoring frustration, and hair-trigger escalation on every frustrated message. You de-escalate with a real fix first. Only if the customer repeats the demand for a human (an explicit request) do you hand off.
# Emotion handling ≠ sentiment-triggered escalation
GUIDANCE = """When a customer expresses frustration:
1. Acknowledge how they feel, briefly and sincerely.
2. Propose a concrete, specific next step or fix.
3. Escalate to a human ONLY if they reiterate the
request for one. Do not escalate on tone alone.
"""Escalate With Structured Context
Escalation is not a dead end — it's a handoff. The human (or supervising system) needs context to act, so pass it in a structured form:
- Failure / trigger type (policy_gap, no_progress, threshold_violation, explicit_request)
- Attempted actions and queries
- Partial results already gathered
- Alternatives considered
A generic 'could not complete request' blocks recovery. Structured context lets the human resume instantly instead of starting from zero.
escalate_to_human(
trigger="policy_gap",
customer_id=verified_id,
attempted_actions=["lookup_order", "check_refund_policy"],
partial_results={"order": order, "policy_match": None},
alternatives_considered=["store_credit", "partial_refund"],
summary="No policy rule covers digital-gift refunds.",
)Don't Guess: Disambiguate Before Acting
A subtle trigger-adjacent rule: when the agent cannot uniquely identify the subject — e.g. multiple customers match the given name — it must ask for more identifiers, never guess.
Guessing the wrong customer is a silent, high-cost error. This isn't an emotional or confidence judgment; it's an objective ambiguity in the data, handled by requesting disambiguation. Combined with identity-verification preconditions (block sensitive actions until get_customer returns a verified ID), it keeps the agent from acting on the wrong record.
matches = lookup_customer(name="Alex Kim")
if len(matches) == 0:
respond("I couldn't find an account with that name.")
elif len(matches) > 1:
# Never pick one — ask for a disambiguating identifier
respond("I found several accounts. What's your order "
"number or email so I can pull the right one?")
else:
proceed(matches[0])Putting the Triggers Together
A robust agent layers these triggers in priority order. An explicit request short-circuits everything. Threshold violations are enforced by hooks, not hope. Policy gaps and no-progress are model-recognized but escalated with structured context.
Crucially, escalation logic lives alongside the agentic loop, not inside its termination check. You still terminate the loop on stop_reason — never by parsing text — while these triggers decide when a human enters. Deterministic where stakes are high, model-driven where judgment is genuinely needed.
def route(state, user_msg):
if explicit_human_request(user_msg): # Trigger 1
return escalate("explicit_request")
if state.action and over_threshold(state.action): # Trigger 4 (hook-backed)
return escalate("threshold_violation")
if state.policy_match is None: # Trigger 2
return escalate("policy_gap")
if state.attempts_exhausted: # Trigger 3
return escalate("no_progress")
return continue_agent_loop(state)Quick Check: Choosing the Right Trigger
Test your judgment on a realistic support-agent design decision.
Recap: Clear Escalation Triggers
Key takeaways:
- Four good triggers: explicit human request (escalate immediately), policy gap, no progress after real attempts, threshold violation.
- Bad triggers: sentiment analysis, model self-rated confidence, untrained classifiers — noisy and unauditable.
- High-stakes thresholds (refund > $500) belong in deterministic hooks, not prompts.
- Emotion pattern: acknowledge → propose a fix → escalate only if the request is reiterated.
- Escalate with structured context (trigger type, attempts, partial results, alternatives) so a human can resume instantly.
- Ambiguous identity? Ask for more identifiers — never guess.
Objective triggers plus deterministic enforcement where it counts: that's architect-grade escalation design.
자주 묻는 질문
“명확한 에스컬레이션 조건” 강의는 무료인가요?
네 — “명확한 에스컬레이션 조건” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Claude Architect 강의 전체를 잠금 해제할 수 있습니다. Claude Architect 강의에는 총 4개의 강의가 포함되어 있습니다.
“명확한 에스컬레이션 조건”에서 뭘 배우나요?
명시적 요청, 정책 공백, 진행 없음 및 임계값을 다룹니다 브라우저에서 직접 실행하는 실습 코드로 Claude Architect을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.
Claude Architect을(를) 시작하는 데 경험이 필요한가요?
사전 경험은 필요하지 않습니다. CoddyKit의 Claude Architect은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.
“명확한 에스컬레이션 조건” 강의는 얼마나 걸리나요?
대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.
이 Claude Architect 강의에서 코드를 작성하고 실행할 수 있나요?
네. 모든 Claude Architect 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.
이 강의의 모든 강의
- 명확한 에스컬레이션 조건
- 안티 패턴: 감정 및 확신 점수
- 구조화된 오류 컨텍스트
- 로컬 복구와 에스컬레이션