This prompt is designed for compliance analysts, risk officers, and audit engineers who need to map unstructured review findings—such as audit notes, control test results, or incident reports—into a predefined, machine-readable risk tier. The core job is classification with mandatory evidence grounding: the model must select a tier from a controlled vocabulary (e.g., Low, Medium, High, Critical) and produce a structured justification that cites specific observations from the input. This is not a general summarization task; it is a structured data extraction and normalization task where the output feeds directly into governance, risk, and compliance (GRC) systems, dashboards, or regulatory filings.
Prompt
Risk Tier Assignment Prompt for Compliance Reviews

When to Use This Prompt
Defines the specific compliance workflow, required inputs, and operational boundaries for the Risk Tier Assignment Prompt.
Use this prompt when you have a stable, well-documented risk tier taxonomy that is owned by your compliance or risk management function. The input must contain sufficient factual observations to support a tier assignment—vague or purely speculative input will produce unreliable results. The prompt expects a [CONTEXT] block containing the review findings and a [TIER_DEFINITIONS] block that maps each tier to its criteria, impact thresholds, and required evidence types. You should not use this prompt for real-time operational alerting where latency is critical, nor for legal advice or final regulatory determinations without human review. It is also unsuitable for domains where the risk taxonomy changes frequently or is highly subjective without clear written criteria.
Before deploying, you must validate the output against your tier schema and test boundary cases where findings could reasonably map to two adjacent tiers. The prompt includes an [OUTPUT_SCHEMA] with a justification field that forces the model to ground its decision in the provided evidence. In production, always route outputs through a validation layer that checks for out-of-vocabulary tier labels and missing justification fields. For high-risk compliance workflows, implement a human-in-the-loop review step for any assignment at the High or Critical tier, and log every assignment with the model version, input hash, and reviewer identity for audit trail purposes. If your review findings are multi-page documents, consider pre-processing them into a structured summary before passing them to this prompt to improve tier boundary precision.
Use Case Fit
Where the Risk Tier Assignment Prompt delivers reliable, auditable results—and where it introduces operational risk that requires a different approach.
Good Fit: Structured Review Workflows
Use when: compliance analysts complete a standardized review checklist and need findings mapped to a predefined risk tier (Low, Medium, High, Critical). Guardrail: Provide the tier definitions and the completed review evidence as explicit input fields. The prompt should only perform the mapping, not conduct the review itself.
Bad Fit: Raw Document Triage
Avoid when: the input is a raw, unread contract or policy document with no prior human analysis. The model may miss latent risks or misclassify severity. Guardrail: Use a separate document review prompt first to extract findings, then feed structured findings into this prompt for tier assignment.
Required Inputs
What to watch: missing or incomplete inputs cause the model to guess the risk tier, producing un-auditable results. Guardrail: Require three explicit inputs: the predefined risk tier definitions, the structured review findings, and the evidence sources. Reject the request if any input is missing rather than proceeding with defaults.
Operational Risk: Boundary Disputes
What to watch: findings that fall near tier boundaries (e.g., Medium vs. High) produce inconsistent assignments across similar cases. Guardrail: Include a tie-breaking rule in the prompt (e.g., 'when evidence supports either tier, assign the higher tier and flag for human review'). Log all boundary decisions for audit sampling.
Operational Risk: Evidence Drift
What to watch: the model justifies a tier with reasoning not present in the provided evidence, creating a false audit trail. Guardrail: Require the output to include a direct quote or reference from the input evidence for each justification field. Run an eval that checks whether justifications are grounded in the provided sources.
Scale Limit: High-Volume Streaming
Avoid when: you need sub-second tier assignment on a high-throughput stream of thousands of events per second. Guardrail: For real-time streaming, use a lightweight classifier model or rule-based system for initial tiering, then sample edge cases through this prompt for calibration and audit. Reserve LLM-based assignment for batch review workflows.
Copy-Ready Prompt Template
A reusable prompt template for mapping compliance review findings to predefined risk tiers with required justification and evidence grounding.
The following prompt template is designed to be copied directly into your AI harness, test suite, or orchestration layer. It uses square-bracket placeholders that your application must resolve before sending the request to the model. Each placeholder represents a variable input, a schema constraint, or a behavioral rule that you control at runtime. Do not ship this template with unresolved placeholders in production—your prompt assembly logic should validate that every required field is populated before the model call is made.
textYou are a compliance risk tier assignment system. Your job is to review the provided compliance finding and assign exactly one risk tier from the controlled vocabulary below. You must provide a structured justification that references specific evidence from the finding. Do not invent risks, assume severity, or assign tiers outside the predefined list. ## RISK TIER VOCABULARY You may only assign one of the following tiers: - CRITICAL: Immediate regulatory or legal exposure requiring escalation within 24 hours. Evidence of active violation, imminent harm, or mandatory reporting trigger. - HIGH: Significant compliance gap with potential regulatory consequences if unaddressed. Evidence of policy violation, control failure, or repeat finding. - MEDIUM: Notable deviation from expected controls or procedures. Evidence of inconsistent practice, documentation gap, or single-instance lapse without systemic indicators. - LOW: Minor procedural deviation or documentation improvement opportunity. Evidence of isolated issue with no immediate compliance impact. - INFORMATIONAL: Observation, recommendation, or best-practice suggestion with no compliance obligation. No evidence of control weakness or policy violation. ## INPUT [FINDING_TEXT] ## CONTEXT Review Date: [REVIEW_DATE] Applicable Framework(s): [FRAMEWORKS] Business Unit: [BUSINESS_UNIT] Reviewer Notes: [REVIEWER_NOTES] ## CONSTRAINTS [CONSTRAINTS] ## OUTPUT SCHEMA Return a single JSON object with the following structure: { "risk_tier": "<one of: CRITICAL | HIGH | MEDIUM | LOW | INFORMATIONAL>", "confidence": "<HIGH | MEDIUM | LOW>", "justification": { "summary": "<one-sentence summary of the finding>", "tier_rationale": "<specific reason this tier was selected over adjacent tiers>", "evidence_cited": ["<direct quote or paraphrase from the finding text>"], "framework_reference": ["<applicable framework clause or control ID, or null if none>"], "escalation_recommended": <true | false>, "escalation_reason": "<reason for escalation recommendation, or null if false>" }, "uncertainty_notes": "<any ambiguity, missing information, or boundary concerns, or null if none>" } ## EXAMPLES [EXAMPLES] ## INSTRUCTIONS 1. Read the finding text carefully. Identify the core compliance issue, if any. 2. Compare the finding against the risk tier definitions. If the finding straddles two tiers, select the higher tier and explain the boundary decision in tier_rationale. 3. Cite specific evidence from the finding text. Do not paraphrase without quoting or closely referencing the source language. 4. If the finding text is insufficient to determine a tier confidently, set confidence to LOW and explain what information is missing in uncertainty_notes. 5. If no compliance issue is present, assign INFORMATIONAL and explain why no higher tier applies. 6. Recommend escalation only when the assigned tier is CRITICAL or HIGH, or when the finding suggests a pattern that could become CRITICAL or HIGH if unaddressed. 7. Return only the JSON object. No markdown, no commentary, no additional text.
To adapt this template for your environment, replace each placeholder with concrete values or application logic. [FINDING_TEXT] should receive the raw text of the compliance finding. [FRAMEWORKS] should list the specific regulatory or internal frameworks in scope, such as SOC 2, HIPAA, or PCI DSS. [CONSTRAINTS] is your injection point for additional business rules—for example, 'Auto-escalate any finding related to customer data exposure' or 'Downgrade first-time procedural findings to LOW unless systemic.' [EXAMPLES] should contain few-shot demonstrations covering boundary cases, such as a finding that appears HIGH but resolves to MEDIUM due to mitigating controls. If your compliance team maintains a tier decision log, sample from it to keep examples grounded in real organizational patterns. Before deploying, validate that your prompt assembly pipeline rejects requests with missing [FINDING_TEXT] or [FRAMEWORKS] fields, and log every assignment with the full prompt context for auditability.
Prompt Variables
Inputs the Risk Tier Assignment Prompt needs to work reliably. Each placeholder must be populated before the prompt is sent to the model. Validation notes describe how to check that the input is well-formed and safe.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[REVIEW_FINDINGS] | Unstructured text describing the compliance review observations, evidence, and any noted deficiencies. | During the Q3 review of vendor X, we observed that access control logs were incomplete for 14 days in July. No evidence of unauthorized access was found, but the gap violates policy AC-3. | Must be non-empty string. Check length < 4000 tokens to avoid truncation. Strip PII if present before insertion. |
[RISK_TIER_DEFINITIONS] | A controlled vocabulary of risk tiers with their definitions, criteria, and required justification fields. | CRITICAL: Immediate threat to operations, regulatory standing, or customer data. Requires executive notification. Justification must cite specific control failure and impact evidence. | Must be a valid JSON array of objects with 'tier', 'definition', 'criteria', and 'required_justification_fields' keys. Validate against schema before prompt assembly. |
[EVIDENCE_SOURCES] | List of source documents, interviews, or system outputs that ground the review findings. | Source 1: Access control audit log export (ac_audit_q3.csv). Source 2: Policy AC-3 revision dated 2024-01-15. Source 3: Interview with system owner J. Chen on 2024-09-10. | Must be an array of strings, each with a source label and brief description. Null allowed if findings are self-contained. Check for broken references to sources not provided in context. |
[OUTPUT_SCHEMA] | The exact JSON schema the model must conform to, including tier field, justification fields, confidence score, and evidence citations. | {"type": "object", "properties": {"assigned_tier": {"enum": ["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFORMATIONAL"]}, "justification": {"type": "string"}, "confidence": {"type": "number", "minimum": 0, "maximum": 1}, "evidence_citations": {"type": "array", "items": {"type": "string"}}}, "required": ["assigned_tier", "justification", "confidence", "evidence_citations"]} | Must be a valid JSON Schema (draft-07 or later). Validate with a schema validator before prompt assembly. Enum values in schema must match [RISK_TIER_DEFINITIONS] exactly. |
[CONSTRAINTS] | Hard rules the model must follow: tier boundary decision logic, abstention conditions, and evidence grounding requirements. | If findings describe a potential regulatory violation but evidence is incomplete, assign HIGH not CRITICAL and note missing evidence in justification. Never assign a tier without citing at least one evidence source. | Must be a non-empty string or array of strings. Review constraints for conflicts with tier definitions. Ensure abstention rules cover all edge cases where evidence is insufficient. |
[FEW_SHOT_EXAMPLES] | Optional. 2-4 examples of review findings mapped to correct risk tiers with justifications, used to calibrate boundary decisions. | Example 1: Finding: 'Minor documentation gap in change management log.' Tier: LOW. Justification: 'No control failure, no impact. Documentation gap is administrative.' Confidence: 0.95. | If provided, must be an array of objects matching the output schema structure. Validate each example against [OUTPUT_SCHEMA]. Check that examples cover tier boundaries, not just clear-cut cases. Null allowed if zero-shot is preferred. |
[ABSTENTION_RULES] | Conditions under which the model should refuse to assign a tier and instead return an abstention response. | Abstain if findings contain contradictory evidence that cannot be resolved from provided sources. Abstain if findings describe a scenario not covered by any tier definition. Return abstention with reason code and unresolved questions. | Must be a non-empty string or array of strings. Ensure abstention response format is defined in [OUTPUT_SCHEMA] or [CONSTRAINTS]. Test that abstention rules do not conflict with tier assignment criteria. |
Implementation Harness Notes
How to wire the risk tier assignment prompt into a production compliance review pipeline with validation, retries, and human escalation.
The risk tier assignment prompt is not a standalone document—it is a classification step inside a larger compliance review workflow. In production, this prompt typically sits behind an API endpoint that receives a structured review finding (evidence summary, control references, reviewer notes) and returns a tier label with justification. The application layer is responsible for enforcing the output contract: the model must return exactly one tier from the predefined set, a non-empty justification grounded in the provided evidence, and a confidence indicator. Before the response reaches any downstream system (case management, regulatory filing, audit log), it must pass automated validation against the tier schema and evidence-grounding rules.
Wire the prompt into your application with a validate-then-escalate pattern. After the model returns a JSON response, run a validator that checks: (1) the risk_tier field matches one of the allowed enum values, (2) the justification field is non-empty and references at least one specific fact from the input evidence, (3) the confidence field is within the expected range, and (4) no extra or missing required fields exist. If validation fails, retry once with the validation error message appended to the prompt context. If the retry also fails, route the review to a human compliance analyst with the original inputs, the failed model outputs, and the validation errors clearly flagged. For high-severity tiers (e.g., CRITICAL or HIGH), consider requiring human approval even when validation passes—add a review queue step before the tier assignment is committed to the system of record.
Model choice matters here. Use a model with strong instruction-following and low refusal rates on compliance content. Temperature should be set low (0.0–0.2) to minimize tier boundary drift. If your compliance framework changes—new tiers, renamed categories, updated evidence requirements—update the [TIER_DEFINITIONS] and [EVIDENCE_RULES] placeholders in the prompt template and run your regression test suite before deploying. Log every assignment with the full prompt, model response, validation result, and human review outcome. These logs become audit evidence for demonstrating consistent, defensible tier assignment decisions over time. Avoid using this prompt for real-time blocking decisions (e.g., transaction holds) without human-in-the-loop confirmation; the cost of a misclassified tier is too high to automate fully without review gates.
Common Failure Modes
Risk tier assignment fails when the model invents tiers, ignores evidence, or makes inconsistent boundary calls. These are the most common failure modes and how to prevent them in production.
Out-of-Vocabulary Tier Invention
What to watch: The model assigns a risk tier not present in the predefined schema, such as 'Medium-High' when only 'Low', 'Medium', 'High', and 'Critical' are allowed. This breaks downstream automation that expects exact enum matches. Guardrail: Enforce the tier list as an enum constraint in the output schema. Add a post-generation validator that rejects any output with an unrecognized tier value and triggers a retry with the allowed list repeated in the error message.
Missing or Hallucinated Justification
What to watch: The model returns a tier without required justification fields, or fabricates evidence references that don't exist in the source material. This makes audit trails unreliable and erodes trust in automated decisions. Guardrail: Require justification fields as non-nullable in the output schema. Implement an evidence-grounding check that verifies each justification claim against spans in the input document. Flag outputs with unsupported claims for human review.
Boundary Inconsistency Across Similar Inputs
What to watch: Two reviews with nearly identical findings receive different risk tiers because the model applies tier criteria inconsistently. This creates compliance risk and undermines the credibility of the automated system. Guardrail: Maintain a golden dataset of boundary-case examples with expected tier assignments. Run regression tests comparing new outputs against these examples. When tier boundaries shift, require explicit calibration before deployment.
Over-Reliance on Surface Keywords
What to watch: The model assigns a high-risk tier based on the presence of alarming keywords without understanding context, severity, or mitigating factors. This produces false positives that overwhelm review queues. Guardrail: Include few-shot examples that demonstrate contextual reasoning over keyword matching. Add a calibration step that compares the model's tier distribution against a human-labeled baseline to detect keyword-driven bias.
Defaulting to the Safest Tier Under Ambiguity
What to watch: When evidence is unclear, the model consistently defaults to the highest risk tier as a safety behavior. This floods escalation paths and desensitizes reviewers to genuine high-risk cases. Guardrail: Add an explicit 'Insufficient Evidence' handling rule in the prompt that requires the model to flag ambiguity rather than over-escalate. Include a confidence score field and route low-confidence assignments to a separate triage queue.
Ignoring Tier Preconditions and Dependencies
What to watch: The model assigns a tier that requires specific preconditions to be met without verifying those preconditions are satisfied in the evidence. For example, assigning 'Critical' without confirming the required impact threshold. Guardrail: Embed tier precondition checks as explicit reasoning steps in the prompt. Require the model to output a precondition verification block before the final tier assignment. Validate this block programmatically before accepting the output.
Evaluation Rubric
Criteria for evaluating the quality of risk tier assignments before integrating the prompt into a production compliance review pipeline. Each criterion includes a pass standard, a failure signal, and a test method for automated or manual review.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Tier Validity | Output tier is an exact string match from the [ALLOWED_TIERS] controlled vocabulary. | Output contains a tier not in [ALLOWED_TIERS], a misspelling, or a tier from a different framework. | Schema check: Assert output tier is in the predefined enum list. |
Evidence Grounding | The [JUSTIFICATION] field contains at least one direct quote or specific reference from the [REVIEW_FINDINGS] input. | The justification is generic, speculative, or references information not present in the input. | Citation check: Verify a substring of the justification exists in the source [REVIEW_FINDINGS] text. |
Tier Boundary Adherence | The assigned tier matches the decision logic defined in the [TIER_DEFINITIONS] rubric for the given findings. | The model assigns a higher or lower tier than the rubric dictates for a clear-cut case, indicating boundary confusion. | Golden dataset test: Run prompt on pre-labeled edge cases and measure exact match accuracy against expected tiers. |
Justification Completeness | The [JUSTIFICATION] field is non-empty and contains a rationale sentence connecting the finding to the tier definition. | The justification field is null, an empty string, or a simple restatement of the tier name without reasoning. | Null and length check: Assert justification string is not null and has a minimum character length. |
Output Schema Conformance | The output is valid JSON that parses without errors and contains all required fields: [TIER], [JUSTIFICATION], [CONFIDENCE_SCORE]. | The output is malformed JSON, is missing a required field, or contains an extra key not in the [OUTPUT_SCHEMA]. | Schema validation: Parse the output with a JSON schema validator configured with the expected contract. |
Confidence Score Calibration | The [CONFIDENCE_SCORE] is a number between 0.0 and 1.0, and is below 0.7 when the [REVIEW_FINDINGS] contain conflicting evidence. | The confidence score is always 1.0, is outside the 0-1 range, or is high when the justification explicitly notes ambiguity. | Boundary and logic check: Assert 0.0 <= score <= 1.0. In a test case with mixed signals, assert score < 0.7. |
Abstention on Ambiguity | When [REVIEW_FINDINGS] are insufficient, the model outputs a tier of 'UNCLEAR' or 'INSUFFICIENT_DATA' as defined in [ALLOWED_TIERS]. | The model guesses a specific risk tier despite a lack of evidence, or hallucinates findings to justify a tier. | Abstention test: Run prompt on an empty or vague input and assert the output tier is the designated abstention label. |
Handling of Multi-Finding Inputs | When multiple distinct findings exist, the model assigns the highest applicable risk tier and justifies it based on the most severe finding. | The model averages the risk, assigns a tier based on the first finding only, or fails to acknowledge the most critical issue. | Multi-issue test: Run prompt on a synthetic input with one 'Critical' and one 'Low' finding and assert the output tier is 'Critical'. |
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
Use the base prompt with a simplified tier list and lighter validation. Start with 3 tiers instead of 5. Accept free-text justification without strict schema enforcement. Run 20–30 sample reviews to observe tier boundary behavior before hardening.
Watch for
- Tier drift: similar findings landing in different tiers across runs
- Missing justification fields when the model is uncertain
- Over-assignment to the middle tier as a safe default

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