This prompt is for trust and safety engineers investigating a user-reported false positive refusal. The model refused a request that the user believes was legitimate. Your job is to compare the user's stated intent against the safety filter's activation signal captured in the production trace to determine whether the refusal was unwarranted. Use this prompt when you have access to the full trace data including the user input, the safety filter's activation reason, the refusal message, and any preceding conversation context. This prompt produces a structured misclassification verdict, the evidence supporting that verdict, and a recommended remediation action.
Prompt
Safety Filter False Positive Trace Diagnosis Prompt

When to Use This Prompt
Defines the job-to-be-done, required context, and boundaries for the Safety Filter False Positive Trace Diagnosis Prompt.
Do not use this prompt for real-time blocking decisions or for investigating false negatives where the model failed to refuse harmful content. It is designed for post-hoc, human-in-the-loop diagnosis of a single trace. The prompt requires a complete trace payload: the raw user input, the exact refusal message returned, the safety filter's activation reason and confidence score, and the conversation history leading up to the refusal. Without this full context, the model cannot reliably distinguish between a legitimate safety activation and an over-refusal triggered by a keyword collision or ambiguous phrasing. The output is a structured JSON verdict that includes a misclassification boolean, a confidence score, an evidence array citing specific trace fields, and a remediation recommendation such as adjusting a keyword list, refining a system prompt boundary, or adding a clarifying user prompt.
Before running this prompt, confirm that the trace is complete and that the user has provided a clear statement of their original intent. If the trace is missing the safety filter's activation reason or the conversation history is truncated, the diagnosis will be unreliable. After receiving the output, always apply human review to the verdict before taking action—especially if the recommended remediation involves modifying a safety policy or system prompt. Use the structured output to log the decision in your incident tracking system and to build a dataset of false positive patterns that can inform future filter tuning.
Use Case Fit
This prompt is designed for structured forensic diagnosis of a single false positive. It is not a bulk classifier, a real-time filter, or a replacement for policy review.
Good Fit: Single-Event Forensic Diagnosis
Use when: a user reports a specific, identifiable refusal event and you have the full trace. The prompt excels at comparing the user's stated intent against the safety signal to produce a misclassification verdict and evidence. Guardrail: always provide the raw trace and the user's appeal text as separate, clearly delimited inputs.
Bad Fit: Real-Time or Bulk Classification
Avoid when: you need to reclassify thousands of events in a batch pipeline or make a blocking decision in a live request path. This prompt is designed for human-in-the-loop investigation, not automated filtering. Guardrail: use a lightweight classifier prompt for bulk triage and reserve this playbook for escalated samples.
Required Inputs
What to watch: the prompt requires the user's original request, the model's refusal output, and the activated safety filter signal with its metadata. Missing any of these degrades the verdict quality. Guardrail: validate that the trace contains the filter activation reason, score, and the exact input that triggered it before running the diagnosis.
Operational Risk: Over-Reliance on Automation
Risk: treating the prompt's output as a final policy decision without human review can propagate errors in safety judgments. The model may misclassify a true positive as a false positive. Guardrail: route all 'likely false positive' verdicts to a human reviewer and log the diagnosis alongside the original trace for auditability.
Operational Risk: Policy Drift
Risk: the prompt's understanding of what constitutes a 'false positive' can drift as the underlying model's safety training changes, even if the prompt text stays the same. Guardrail: periodically test the prompt against a golden set of known false positives and true positives to detect drift in verdict patterns.
Operational Risk: Incomplete Trace Data
Risk: production traces may be truncated, redacted, or missing the specific filter signal that caused the refusal, leading to an incorrect 'inconclusive' or 'false positive' verdict. Guardrail: implement a pre-check that confirms the trace contains the filter activation event before invoking the diagnosis prompt; if missing, flag for manual investigation.
Copy-Ready Prompt Template
A copy-ready prompt template for diagnosing safety filter false positives from production traces.
This prompt is designed to be pasted directly into your investigation workflow. It instructs the model to act as a senior trust and safety engineer, comparing the user's original intent against the safety filter's activation signal captured in a production trace. The goal is to produce a structured misclassification verdict, the evidence supporting that verdict, and a recommended remediation action. Before using this prompt, ensure you have extracted the relevant trace data, including the user's full input, the system prompt or safety instructions active at the time, and the exact refusal message or filter tag that was triggered.
textYou are a senior trust and safety engineer reviewing a production trace for a false positive safety refusal. Your task is to determine if the model's refusal was unwarranted given the user's intent. ## INPUT DATA ### User Request (Full Text) [USER_REQUEST] ### Active Safety Instructions / System Prompt [SYSTEM_PROMPT] ### Refusal Output or Filter Tag [REFUSAL_OUTPUT] ### Additional Trace Context (Tool Calls, Prior Turns) [TRACE_CONTEXT] ## INSTRUCTIONS 1. **Intent Analysis:** Summarize the user's most likely intent in one sentence. Identify any ambiguous terms that could be misinterpreted. 2. **Policy Mapping:** Identify the specific clause or instruction within the [SYSTEM_PROMPT] that most likely triggered the refusal. 3. **Misclassification Verdict:** Classify the event as `TRUE_POSITIVE`, `FALSE_POSITIVE`, or `UNCLEAR`. A false positive means the user's intent was benign and the safety filter over-reacted to a keyword or out-of-context phrase. 4. **Evidence:** Quote the exact text from the [USER_REQUEST] and [SYSTEM_PROMPT] that supports your verdict. 5. **Remediation:** If the verdict is `FALSE_POSITIVE`, recommend a specific, actionable change to the [SYSTEM_PROMPT] or a keyword filter rule to prevent this class of error. If `TRUE_POSITIVE`, explain why the refusal was correct. If `UNCLEAR`, state what additional context is needed. ## CONSTRAINTS - Do not fabricate user intent. Base your analysis strictly on the provided trace. - If the trace data is insufficient for a high-confidence verdict, you MUST classify the event as `UNCLEAR`. - Your remediation suggestion must be a concrete text edit or rule change, not a general principle. ## OUTPUT SCHEMA { "user_intent_summary": "string", "ambiguous_terms": ["string"], "triggering_policy_clause": "string", "verdict": "TRUE_POSITIVE" | "FALSE_POSITIVE" | "UNCLEAR", "evidence": { "user_request_quote": "string", "policy_quote": "string" }, "remediation_action": "string", "confidence_score": 0.0-1.0 }
To adapt this template, replace the square-bracket placeholders with data from your observability platform. The [TRACE_CONTEXT] field is critical for multi-turn conversations where the refusal may be triggered by an earlier exchange. If your safety system uses a numeric filter tag instead of a text refusal, place that identifier in [REFUSAL_OUTPUT]. For high-risk domains, always route UNCLEAR verdicts and any FALSE_POSITIVE with a confidence score below 0.9 to a human review queue before implementing the suggested remediation. The structured JSON output is designed to be logged directly into your incident tracking system for trend analysis.
Prompt Variables
Inputs the prompt needs to work reliably. Validate each before running the diagnosis.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[USER_REPORT] | The original complaint from the user claiming a false positive refusal. | User states: 'I asked for a recipe for apple pie and it blocked me for harmful content.' | Must be a non-empty string. Check for minimum length (>10 chars) to avoid empty reports. Flag if it contains only a URL without description. |
[USER_INTENT] | A clear, neutral restatement of what the user was actually trying to accomplish. | User intended to request a common baking recipe with no harmful, illegal, or policy-violating elements. | Must be manually extracted or generated by a prior step. Validate it is a declarative sentence. Null not allowed; if intent is unclear, set to 'UNCLEAR' and flag for human review. |
[SAFETY_FILTER_SIGNAL] | The raw activation metadata from the safety filter captured in the trace. | {"filter_name": "content_policy_v2", "activation_reason": "flagged_term: 'apple'", "confidence": 0.92} | Must be valid JSON. Validate schema: requires 'filter_name' (string), 'activation_reason' (string), and 'confidence' (float 0-1). Reject if confidence is null. |
[FULL_TRACE_LOG] | The complete, unredacted trace log for the specific request, including all tool calls and intermediate steps. | JSON array of trace events with timestamps, spans, and I/O payloads. | Must be valid JSON array. Validate it contains at least one event with the user's original prompt. Check for truncation; if the trace is incomplete, set a flag and do not proceed with diagnosis. |
[POLICY_DOCUMENT] | The specific content safety policy or content moderation guidelines that were active at the time of the request. | Section 3.1: 'Do not generate content that facilitates illegal acts. Recipes for food are not in scope.' | Must be a non-empty string. Validate it contains a version number or effective date. If the policy is missing, the diagnosis must be scoped to 'POLICY_UNAVAILABLE' and not attempt a compliance ruling. |
[MODEL_VERSION] | The identifier for the model and prompt template version that served the request. | gpt-4o-2024-08-06 with system_prompt_hash: a1b2c3 | Must be a non-empty string. Validate format against your deployment registry. If the version cannot be resolved to a known deployment, flag the trace as 'UNTRUSTED' and do not compare against baselines. |
[OVERRIDE_AUTHORIZATION] | A boolean flag indicating if the safety filter was overridden by an authorized actor. | Must be a boolean. If true, the diagnosis must include an audit of the override justification. If the value is null, assume false but log a warning. |
Implementation Harness Notes
How to wire the Safety Filter False Positive Trace Diagnosis Prompt into an investigation workflow or automated review pipeline.
This prompt is designed to be the analytical core of a false positive review pipeline, not a standalone chat interaction. The input trace must be pre-assembled from your observability platform (e.g., LangSmith, Arize, Datadog LLM, or custom logging) before the prompt is called. The prompt expects a structured [TRACE_JSON] input containing the user's original request, the safety filter's activation signal, the refusal message, and any relevant system prompt or policy metadata. Do not pass raw, unparsed log lines; the model needs the trace fields explicitly labeled to produce a reliable verdict.
Wire the prompt into an automated workflow with a pre-processing step that fetches the full trace by trace_id and a post-processing step that validates the JSON output against a strict schema. The expected output includes a verdict enum (FALSE_POSITIVE, LEGITIMATE_REFUSAL, UNCLEAR), an evidence array, and a remediation string. Implement a JSON schema validator in your application layer that rejects malformed responses and triggers a single retry with the validation error message appended to the prompt. If the retry also fails or the verdict is UNCLEAR, escalate the trace to a human review queue with the raw trace and the model's partial analysis attached. Log every verdict, the model version used, and the reviewer's final decision to build a ground-truth dataset for future eval.
For model choice, use a capable reasoning model (e.g., GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro) with a low temperature setting (0.0–0.2) to maximize consistency in verdict classification. Avoid using smaller or faster models for this task, as the comparative reasoning required to distinguish user intent from filter activation signals demands strong instruction-following and nuance. If you are processing a high volume of user-reported false positives, batch the traces and run the prompt asynchronously, but always preserve the ability to trace each verdict back to the exact prompt version and model snapshot. Never auto-apply the model's recommended remediation (e.g., updating a safety keyword list) without human approval; the prompt's remediation field is a suggestion, not an automated action.
Expected Output Contract
Structured output schema for the Safety Filter False Positive Trace Diagnosis Prompt. Use this contract to validate the model's response before routing it to a review queue or automated remediation system.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
verdict | enum: [true_positive, false_positive, uncertain] | Must match one of the three enum values exactly. If the evidence is contradictory or insufficient, set to 'uncertain'. | |
user_intent_summary | string (<= 280 chars) | Must be a plain-text summary of the user's inferred goal. Null or empty string is not allowed. Length must be between 10 and 280 characters. | |
safety_filter_trigger | string | Must be the exact safety category or rule identifier extracted from the trace metadata. If the trace does not contain a label, use the value 'unlabeled'. | |
trigger_evidence | array of objects | Each object must contain 'source' (string: trace segment name), 'content' (string: the exact text or tool call), and 'relevance' (enum: [direct_cause, contributing, contextual]). Array must not be empty. | |
misclassification_reason | string or null | If verdict is 'false_positive', this field is required and must be a non-empty string explaining why the filter activated incorrectly. If verdict is 'true_positive', this field must be null. | |
remediation_action | enum: [adjust_policy_threshold, add_override_rule, update_system_prompt, escalate_for_review, no_action] | Must be one of the five enum values. 'no_action' is only valid when verdict is 'true_positive'. 'escalate_for_review' is required when verdict is 'uncertain'. | |
confidence_score | number (0.0 - 1.0) | Must be a float between 0.0 and 1.0 inclusive. Scores below 0.7 should correlate with verdict 'uncertain'. Parse check: reject non-numeric values. | |
trace_id | string | Must match the [TRACE_ID] input exactly. Reject if the output trace_id does not match the input trace_id. This prevents cross-trace contamination in batch processing. |
Common Failure Modes
What breaks first when diagnosing safety filter false positives and how to guard against it.
Intent vs. Surface-Form Mismatch
What to watch: The safety filter triggers on a keyword or phrase while missing the user's benign intent. A medical query containing anatomical terms gets blocked as explicit content, or a security researcher's exploit description gets refused as attack planning. Guardrail: Always compare the extracted user intent from the full conversation context against the specific filter activation signal. Flag any case where the intent category and the filter category diverge.
Context Window Truncation Blindness
What to watch: The trace shows a refusal but the preceding context that would have clarified the user's legitimate intent fell outside the safety filter's inspection window. The filter saw only the most recent message without the setup. Guardrail: Reconstruct the full conversation context from the trace and re-evaluate. If the refusal would not have occurred with full context, classify as a context-truncation false positive and recommend expanding the filter's context window.
Overlapping Policy Rule Activation
What to watch: Multiple safety policies fire simultaneously on a single request, and the trace attributes the refusal to the wrong policy. A request blocked for 'copyright' was actually caught by a 'harmful content' rule, making remediation target the wrong policy definition. Guardrail: Extract every activated policy rule from the trace with its confidence score. Verify that the primary refusal reason matches the highest-confidence or most-specific rule. Flag mismatches for policy audit.
Instruction Conflict False Trigger
What to watch: The system prompt contains safety instructions that conflict with a legitimate user task. A prompt that says 'never discuss violence' blocks a historian asking about 20th-century conflicts, or a 'refuse all code generation' rule blocks a teacher requesting a sorting algorithm example. Guardrail: Isolate the specific system prompt instruction that triggered the refusal. Test whether removing or scoping that instruction would allow the legitimate use case while still blocking genuine violations.
Multilingual and Locale Misfire
What to watch: The safety filter correctly handles a term in English but misfires on the same term in another language, or a culturally specific reference is misclassified as a policy violation. A harmless phrase in one locale triggers a profanity filter in another. Guardrail: Check the detected language and locale in the trace metadata. If the filter applied English-centric rules to non-English content, flag as a locale mismatch. Recommend locale-aware policy configuration.
Remediation Action Misdirection
What to watch: The diagnosis correctly identifies a false positive but recommends the wrong remediation—suggesting a prompt change when the safety filter threshold needs tuning, or recommending a policy rewrite when the model version caused the regression. Guardrail: Map each root cause category to a specific remediation owner: prompt engineering, safety filter configuration, model version rollback, or policy definition update. Validate that the recommended action matches the root cause before closing the investigation.
Evaluation Rubric
Criteria for assessing the quality of a Safety Filter False Positive Trace Diagnosis output before integrating the prompt into an automated investigation workflow. Each row defines a specific check, a pass standard, a failure signal, and a test method.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Misclassification Verdict Validity | Verdict is exactly one of: 'True Positive', 'False Positive', or 'Uncertain'. | Verdict is missing, null, or an unexpected string. | Schema validation check on the 'verdict' field against the allowed enum. |
Evidence Grounding | Every piece of evidence in the 'evidence_log' array contains a direct quote or a specific reference to a trace event ID. | Evidence contains unsupported claims, hallucinated trace events, or lacks a source reference. | Manual review of 10 samples; automated check that each evidence object has a non-null 'source_trace_id' field. |
Intent vs. Signal Comparison | The 'analysis' field explicitly compares the user's stated intent with the specific safety filter rule that activated. | The analysis only describes the user's intent or the filter rule in isolation, without a direct comparison. | LLM-as-a-Judge evaluation using a pairwise comparison prompt; check for the co-occurrence of intent and filter rule keywords. |
Remediation Action Appropriateness | The 'recommended_action' is a concrete, implementable step (e.g., 'Add [TERM] to allowlist', 'Adjust policy threshold for [RULE_ID]'). | Action is vague (e.g., 'Fix the filter'), missing, or suggests disabling the filter entirely without a specific justification. | Human expert review of 20 samples; automated check that the action string is not empty and does not match a blocklist of generic phrases. |
Confidence Score Calibration | The 'confidence_score' (0.0-1.0) is above 0.9 for clear-cut cases and below 0.7 for ambiguous cases. | Score is consistently 0.99 or 0.0, or is inversely correlated with the complexity of the trace. | Statistical analysis of score distribution across 100+ traces; check for variance and correlation with 'Uncertain' verdicts. |
Uncertain Case Handling | When the verdict is 'Uncertain', the output includes a specific, unanswered question or a missing piece of information that prevents a decision. | The output is 'Uncertain' but provides no justification, or the justification is a restatement of the verdict. | Filter for 'Uncertain' verdicts and validate that the 'missing_information' field is populated and non-generic. |
Output Schema Compliance | The final JSON output is valid and contains all required fields: 'verdict', 'analysis', 'evidence_log', 'recommended_action', 'confidence_score'. | Output is missing a required field, contains extra fields, or is not valid JSON. | Automated JSON Schema validation in a test harness run against a golden dataset of 50 traces. |
Human Approval Flagging | The 'requires_human_review' flag is set to 'true' for all 'Uncertain' verdicts and for any 'False Positive' verdict with a confidence score below 0.8. | The flag is 'false' for an 'Uncertain' verdict, or 'false' for a low-confidence false positive. | Rule-based assertion in the evaluation script: if verdict == 'Uncertain' or (verdict == 'False Positive' and confidence_score < 0.8), then requires_human_review must be true. |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Adapt This Prompt
How to adapt
Add strict JSON output schema, retry logic, and eval cases. Wire the prompt into a trace review pipeline that logs every diagnosis for audit.
- Enforce a typed output:
{"verdict": "FALSE_POSITIVE" | "CORRECT_REFUSAL" | "UNCLEAR", "evidence": [...], "remediation": "..."} - Add a validator that checks
evidencearray length ≥ 2 andremediationis non-empty. - Include a retry prompt:
The previous output failed validation. Re-examine the trace and provide missing fields. - Log the diagnosis alongside the trace ID, reviewer identity, and timestamp.
Watch for
- Silent format drift when the model returns extra fields or wrong enum values
- Missing human review for UNCLEAR verdicts before remediation is applied
- Evidence that quotes the refusal message but ignores the user's original intent

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us