This prompt is designed for AI quality teams and RAG operations engineers who need a structured, multi-dimensional assessment of whether retrieved evidence is sufficient to answer a user query. It produces a scorecard that evaluates evidence across five dimensions: relevance, completeness, authority, recency, and specificity. The output is suitable for ingestion into monitoring dashboards, SLA tracking, and continuous retrieval quality improvement workflows. Use this prompt when you need a repeatable, calibrated method to score retrieval sets before they reach answer generation.
Prompt
Evidence Sufficiency Scorecard Prompt

When to Use This Prompt
Defines the ideal user, operational context, and boundaries for the Evidence Sufficiency Scorecard Prompt.
The ideal deployment context is an offline or asynchronous evaluation pipeline, not a real-time user-facing code path. You should wire this prompt into a batch evaluation harness that samples production queries, retrieves evidence from your current pipeline, and runs the scorecard against a representative query set. Store the structured scores alongside query metadata, retriever configuration, and timestamp so you can track retrieval quality trends over time, compare retriever versions, and set objective thresholds for promotion to production.
Do not use this prompt for real-time answer generation or for making binary answer/don't-answer decisions. It is a diagnostic instrument, not a gating mechanism. Pair it with a downstream gating prompt—such as the RAG Sufficiency Gate or Answer Abstention Decision Prompt—when you need a production guardrail. Also avoid using this prompt on queries where the retrieval set is trivially empty; the scorecard assumes at least one candidate passage exists to evaluate. For empty retrieval sets, route directly to a missing-context or refusal workflow.
Use Case Fit
The Evidence Sufficiency Scorecard is a diagnostic tool, not a real-time guardrail. It excels in offline evaluation and monitoring pipelines but can introduce latency and cost if misapplied to synchronous user-facing flows.
Good Fit: RAG Pipeline Monitoring
Use when: You need continuous, multi-dimensional quality metrics for your retrieval pipeline. The scorecard's breakdown across relevance, completeness, authority, recency, and specificity makes it ideal for dashboards and SLAs. Guardrail: Run the scorecard on a representative sample of production queries, not every request, to manage cost and latency.
Good Fit: Pre-Deployment Evaluation
Use when: Validating a new retriever, embedding model, or knowledge base before production release. The structured output allows for systematic comparison across versions. Guardrail: Pair the scorecard with a fixed golden dataset of queries and ground-truth evidence sets to ensure consistent, repeatable evaluation.
Bad Fit: Real-Time Answer Guardrail
Avoid when: You need a fast, binary decision on whether to answer a user's query. The scorecard's detailed, multi-dimensional analysis adds significant latency. Guardrail: Use a lightweight Context Adequacy Binary Classifier Prompt for synchronous pre-generation checks, reserving the scorecard for async analysis.
Required Inputs: Structured Evidence Set
Risk: The scorecard's output is only as good as the evidence it evaluates. Passing a flat, unformatted text blob will produce unreliable scores. Guardrail: The prompt requires a structured list of passages, each with a unique ID, source title, and publication date. Enforce this schema in your application code before calling the prompt.
Operational Risk: Score Drift and Calibration
Risk: Over time, the model's interpretation of the scoring rubric can drift, leading to inflated or inconsistent scores that mask real retrieval problems. Guardrail: Implement a calibration step. Periodically run the scorecard on a held-out set of queries with human-verified sufficiency labels and compare the model's scores to detect drift.
Operational Risk: Cost Overruns
Risk: The detailed analysis requires a large context window and generates a long output, making it expensive to run on high-volume query streams. Guardrail: Implement sampling (e.g., 5% of traffic) and set hard monthly budget caps. Trigger full evaluations only during deployment windows or when monitoring detects a potential quality regression.
Copy-Ready Prompt Template
A reusable prompt that produces a multi-dimensional scorecard assessing evidence sufficiency across relevance, completeness, authority, recency, and specificity.
This template is designed to be dropped directly into your RAG evaluation pipeline or monitoring harness. It instructs the model to act as an evidence auditor, evaluating a set of retrieved passages against a user query across five calibrated dimensions. The output is a structured JSON scorecard suitable for dashboards, continuous monitoring, and SLA tracking. Replace each square-bracket placeholder with your actual data before sending the prompt to the model.
textYou are an evidence sufficiency auditor. Your task is to evaluate whether the provided evidence passages are sufficient to answer the user query. Produce a structured scorecard assessing sufficiency across five dimensions. ## INPUT **User Query:** [USER_QUERY] **Retrieved Evidence Passages:** [EVIDENCE_PASSAGES] **Domain Context (optional):** [DOMAIN_CONTEXT] ## OUTPUT SCHEMA Return a valid JSON object with this exact structure: { "overall_sufficiency_score": <float 0.0-1.0>, "overall_verdict": "sufficient" | "partially_sufficient" | "insufficient", "dimensions": { "relevance": { "score": <float 0.0-1.0>, "rationale": "<explanation of how well the evidence addresses the query topic and intent>" }, "completeness": { "score": <float 0.0-1.0>, "rationale": "<explanation of whether all aspects of the query are covered by the evidence>" }, "authority": { "score": <float 0.0-1.0>, "rationale": "<explanation of source credibility, expertise indicators, and trustworthiness>" }, "recency": { "score": <float 0.0-1.0>, "rationale": "<explanation of whether the evidence is current enough for the query's temporal requirements>" }, "specificity": { "score": <float 0.0-1.0>, "rationale": "<explanation of how precisely the evidence addresses the query versus providing general or tangential information>" } }, "identified_gaps": [ "<specific missing information needed to fully answer the query>" ], "recommendation": "<actionable guidance: proceed to answer, request more evidence, or refuse>" } ## CONSTRAINTS - Score each dimension independently. Do not let one dimension bias another. - For recency: if the query is time-sensitive, penalize outdated evidence. If the query is timeless, score recency high by default and note this in the rationale. - For authority: consider source reputation, author expertise, publication venue, and presence of citations. Flag sources with no identifiable authority. - For completeness: identify every sub-question or information need in the query and check whether evidence addresses each one. - If evidence is missing critical facts, entities, or temporal context, list these explicitly in identified_gaps. - overall_sufficiency_score must reflect the weighted combination of dimension scores, not an independent judgment. - If the evidence is insufficient, the recommendation must explain what additional evidence is needed. - Do not answer the user query. Only assess evidence sufficiency. ## RISK LEVEL [RISK_LEVEL] If RISK_LEVEL is "high": apply stricter thresholds. Score authority and completeness more conservatively. Flag any unsupported inference risk. Recommend human review when overall_sufficiency_score is below 0.8.
Adaptation guidance: Replace [USER_QUERY] with the end user's question or search intent. [EVIDENCE_PASSAGES] should contain the full text of retrieved chunks, each prefixed with a source identifier for traceability. [DOMAIN_CONTEXT] is optional but valuable for specialized domains such as legal, medical, or financial where authority and specificity standards differ. [RISK_LEVEL] accepts low, medium, or high and adjusts the scoring conservatism accordingly. For production use, wrap this prompt in a validation layer that checks the output JSON against the schema before the scorecard enters your monitoring pipeline. If the model returns malformed JSON, use a repair prompt or retry with stricter format instructions before surfacing results.
Prompt Variables
Required inputs for the Evidence Sufficiency Scorecard Prompt. Each placeholder must be populated before the prompt is assembled and sent. Validation notes describe how to programmatically verify the input before execution.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[QUERY] | The user question or information need being evaluated for evidence sufficiency | What is the impact of the new EU AI Act on open-weight model release requirements? | Non-empty string check. Reject if length < 10 characters or > 2000 characters. Must contain at least one interrogative or information-seeking structure. |
[RETRIEVED_EVIDENCE] | Array of retrieved passages, documents, or chunks to assess for sufficiency against the query | [{"source": "eu-ai-act-article-53.md", "content": "Providers of general-purpose AI models shall draw up and keep up-to-date the technical documentation...", "date": "2024-07-12", "authority": "primary-legislation"}] | Must be a valid JSON array with 1-50 objects. Each object requires content (non-empty string), source (non-empty string). Optional: date, authority, relevance_score. Reject if array is empty or content fields are all null. |
[DIMENSIONS] | List of sufficiency dimensions to score, drawn from relevance, completeness, authority, recency, specificity | ["relevance", "completeness", "authority", "recency", "specificity"] | Must be a valid JSON array of strings. Each string must match an allowed dimension enum: relevance, completeness, authority, recency, specificity. Reject if array is empty or contains unknown dimensions. |
[SCORING_SCALE] | The numeric range and anchors for dimension-level scoring | {"min": 1, "max": 5, "anchors": {"1": "No evidence", "3": "Partial evidence", "5": "Complete evidence"}} | Must be a valid JSON object with min (integer), max (integer), and anchors (object with at least 3 key-value pairs). Min must be less than max. Reject if scale is inverted or anchors are missing. |
[OUTPUT_SCHEMA] | Expected JSON structure for the scorecard output, defining fields and types | {"overall_score": "number", "dimension_scores": "object", "gap_summary": "string", "recommendation": "string"} | Must be a valid JSON schema or type definition object. Each field must specify a type. Reject if schema is empty or contains circular references. Parse check before prompt assembly. |
[AUTHORITY_TIERS] | Ordered list of source authority levels for calibrating the authority dimension score | ["primary-legislation", "regulatory-guidance", "legal-analysis", "news-report", "opinion"] | Must be a valid JSON array of strings with at least 2 tiers. Order matters: first element is highest authority. Reject if array is empty or contains duplicate values. |
[RECENCY_THRESHOLD] | Date or age cutoff for determining whether evidence is current enough for the query domain | {"field": "date", "max_age_days": 180, "prefer_after": "2024-01-01"} | Must be a valid JSON object with at least one of max_age_days (positive integer) or prefer_after (ISO 8601 date string). Reject if both are missing or max_age_days is negative. |
[CONFIDENCE_THRESHOLD] | Minimum overall score required to consider evidence sufficient, used for go/no-go routing | 0.7 | Must be a float between 0.0 and 1.0 inclusive. Reject if value is outside range or non-numeric. Used downstream for answerability gating; log when threshold is changed between evaluations. |
Implementation Harness Notes
How to wire the Evidence Sufficiency Scorecard Prompt into a production RAG pipeline with validation, retries, and monitoring.
The Evidence Sufficiency Scorecard Prompt is designed to operate as a post-retrieval, pre-generation quality gate in a RAG pipeline. After your retriever returns a set of candidate passages but before those passages are sent to an answer-generation model, this prompt evaluates whether the evidence is sufficient. The output is a structured scorecard that can be used for automated routing decisions (answer, request more context, or refuse), dashboard population for retrieval quality monitoring, and SLA tracking. The prompt expects a query, a list of retrieved passages with metadata, and an optional output schema to enforce the scorecard structure.
Implementation flow: 1) Receive user query and retrieve top-k passages. 2) Assemble the prompt by injecting [QUERY], [RETRIEVED_PASSAGES] (with source, date, and authority metadata), and [OUTPUT_SCHEMA] (a JSON schema defining the scorecard fields). 3) Call a capable model (GPT-4o, Claude 3.5 Sonnet, or equivalent) with response_format set to json_object and temperature at or below 0.2 for consistency. 4) Validate the output against your scorecard schema—check that all required dimensions (relevance, completeness, authority, recency, specificity) are present, scores are within expected ranges, and the overall sufficiency verdict is present. 5) If validation fails, retry once with the validation error message appended to the prompt as a correction instruction. 6) Log the full scorecard, retrieval set metadata, and model call details to your observability platform for trace analysis and regression testing. 7) Route based on the overall sufficiency verdict: if sufficient, proceed to answer generation; if insufficient, trigger a gap report or clarification flow.
Critical guardrails: This prompt is a structured evaluation step, not a user-facing response. Do not expose raw scorecard output to end users without interpretation. For high-stakes domains (healthcare, legal, finance), always include a human-review step when the scorecard shows borderline sufficiency or when authority scores are low. Implement a circuit breaker that escalates to human review if the model returns malformed JSON after two retries. Use the scorecard dimensions as monitoring metrics over time: track average completeness scores per knowledge base, detect drift when authority scores decline, and set alerts when the rate of insufficient verdicts spikes. Finally, pair this prompt with the Evidence Sufficiency Rubric for LLM Judge to run automated evals on the scorecard quality itself—ensuring the scorecard prompt remains calibrated as your retrieval pipeline evolves.
Expected Output Contract
Fields, types, and validation rules for the Evidence Sufficiency Scorecard. Use this contract to parse, validate, and store scorecard outputs before they enter dashboards or downstream decision logic.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
scorecard_id | string (UUID v4) | Must match UUID v4 pattern; reject on parse failure | |
query | string | Must be non-empty and match the original [QUERY] input exactly | |
overall_sufficiency_score | number (0.0–1.0) | Must be a float between 0.0 and 1.0 inclusive; reject if out of range or non-numeric | |
dimensions | array of objects | Must contain exactly 5 dimension objects; reject if array length != 5 | |
dimensions[].name | string (enum) | Must be one of: relevance, completeness, authority, recency, specificity; reject unknown dimension names | |
dimensions[].score | number (0.0–1.0) | Must be a float between 0.0 and 1.0 inclusive; reject if out of range or non-numeric | |
dimensions[].rationale | string | Must be non-empty and reference specific evidence passages from [RETRIEVED_EVIDENCE]; flag if rationale is generic or lacks citation | |
answerable | boolean | Must be true or false; reject if null, string, or missing | |
missing_information | array of strings | Required when answerable is false; each string must describe a specific missing fact, entity, or context; reject if empty array when answerable is false | |
confidence_level | string (enum) | Must be one of: high, medium, low, insufficient; reject unknown values | |
recommended_action | string (enum) | Must be one of: auto_answer, answer_with_caveats, request_clarification, refuse; reject unknown actions | |
evidence_citations | array of strings | Each string must match a passage_id from [RETRIEVED_EVIDENCE]; reject if any citation references a non-existent passage_id | |
generated_at | string (ISO 8601 UTC) | Must parse as valid ISO 8601 datetime in UTC; reject on parse failure or non-UTC timezone | |
model_version | string | If present, must match expected model identifier pattern; log warning on mismatch but do not reject |
Common Failure Modes
What breaks first when scoring evidence sufficiency and how to prevent it.
Surface-Level Relevance Over Depth
What to watch: The model assigns high scores because passages mention the right topic, ignoring whether they contain the specific facts needed to answer the query. A passage about 'Q3 earnings' scores well even when it lacks the revenue figure the user asked for. Guardrail: Require the scorecard to cite specific missing facts per dimension. Add a 'factual coverage' sub-score that checks whether the query's explicit data requirements are met, not just topical overlap.
Recency Bias Overriding Authority
What to watch: The model inflates scores for recent but low-quality sources while penalizing older authoritative sources. A blog post from last week outscores a regulatory filing from last quarter. Guardrail: Separate recency and authority into independent dimensions with explicit definitions. Add a rule that recency only matters for time-sensitive queries. For stable facts, authority should dominate the composite score.
False Completeness from Verbose Passages
What to watch: Long passages with many words but few distinct facts receive high completeness scores because the model equates length with coverage. A 500-word passage that repeats the same two facts outscores three short passages covering five distinct facts. Guardrail: Add a 'fact density' or 'information redundancy' check. Require the scorecard to enumerate distinct claims covered, not just passage count or word volume.
Overconfidence on Ambiguous Queries
What to watch: The model assigns high sufficiency scores when the query itself is ambiguous, interpreting the query narrowly and ignoring alternative readings. 'What happened with the deal?' scores high on any deal-related passage, even if the user meant a specific deal. Guardrail: Add a pre-scoring step that identifies query ambiguity. If multiple interpretations exist, the scorecard should note which interpretation was used and flag that evidence may be insufficient for other readings.
Dimension Score Inflation from Halo Effect
What to watch: A strong score on one dimension bleeds into others. A highly authoritative source gets inflated relevance and completeness scores even when it doesn't address the query well. Guardrail: Require independent evidence and justification for each dimension. Use a structured output schema that forces separate reasoning blocks per dimension before the final score. Add eval checks that test for score correlation across unrelated dimensions.
Missing Negative Evidence Handling
What to watch: The scorecard treats absence of contradictory evidence as confirmation of sufficiency. When no passage contradicts a claim, the model assumes the evidence is complete rather than recognizing the evidence set may simply lack coverage. Guardrail: Add an explicit 'negative evidence' check. Ask whether the evidence set contains information that would disprove the answer if it existed. Flag when critical counter-evidence domains are entirely absent from the retrieval set.
Evaluation Rubric
Use this rubric to evaluate the Evidence Sufficiency Scorecard output before integrating it into dashboards, SLAs, or continuous monitoring pipelines. Each criterion targets a specific failure mode in production evidence assessment.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Dimension Score Completeness | All five dimensions (relevance, completeness, authority, recency, specificity) receive a numeric score between 0.0 and 1.0 | Missing dimension, null score, or score outside 0.0–1.0 range | Schema validation: parse output JSON, assert all five dimension keys present with float values in [0.0, 1.0] |
Overall Sufficiency Score Calculation | Overall score is present and falls within the min-max range of the five dimension scores | Overall score is missing, equals exactly 0 or 1 without justification, or falls outside dimension score range | Arithmetic check: compute min and max of dimension scores, assert overall_score >= min and overall_score <= max |
Dimension Rationale Presence | Each scored dimension includes a non-empty rationale string explaining the score | Empty string, null, or missing rationale for any dimension | String validation: assert rationale length > 20 characters for each dimension, reject placeholder text like 'N/A' or 'ok' |
Evidence Citation Mapping | Rationales reference specific evidence passages by index or ID when available | Rationales contain only generic statements with no reference to provided evidence items | Citation check: scan rationale strings for evidence IDs or passage indices matching the input evidence set |
Gap Identification Specificity | Gaps list contains specific missing information items, not generic statements like 'more data needed' | Gaps array is empty when dimension scores are below 0.7, or gaps contain only vague descriptions | Content check: assert each gap entry names a specific fact, entity, timeframe, or data point that is missing |
Confidence Calibration Alignment | Confidence level (high/medium/low) aligns with overall score thresholds: high >= 0.8, medium 0.5-0.79, low < 0.5 | Confidence is 'high' when overall score < 0.5, or 'low' when overall score > 0.8 | Threshold check: map confidence label to expected score range, assert consistency between label and overall_score |
Output Format Stability | Output parses as valid JSON matching the expected schema across 10 repeated runs with identical input | JSON parse failures, missing required fields, or field type changes across repeated runs | Stability test: run prompt 10 times with same input, assert 100% JSON parse success and schema conformance |
Edge Case: Empty Evidence Set | When evidence array is empty, overall score is 0.0, confidence is 'low', and gaps list explains total absence of evidence | Non-zero scores, 'high' or 'medium' confidence, or empty gaps list when no evidence is provided | Edge case test: submit input with empty evidence array, assert overall_score == 0.0, confidence == 'low', gaps.length > 0 |
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 single model call and lighter validation. Remove the strict JSON schema enforcement initially and focus on getting the dimensional scores directionally correct. Use a simple pass/fail check on the overall sufficiency rating.
Prompt modification
- Replace the strict
[OUTPUT_SCHEMA]with a looser request for a JSON object with the five dimensions. - Drop the
[CONSTRAINTS]section about required fields and enum values. - Add a line:
If you are unsure about any dimension, provide your best estimate and flag it with "confidence: low".
Watch for
- Missing schema checks leading to inconsistent field names across runs.
- Overly broad instructions causing the model to skip dimensions.
- Score inflation when the model is uncertain but defaults to mid-range values.

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