This prompt is designed for verification pipeline builders who need a reusable, model-level instruction to classify every sentence in a document. Its job is to separate verifiable factual statements from analysis, opinion, prediction, and rhetorical framing before any fact-checking occurs. The ideal user is an engineer or technical operator integrating this classification step into a larger automated workflow—such as claim extraction, evidence matching, or human review routing. You should use this prompt when downstream tasks require clean, structured labels and confidence scores to avoid misclassifying an analyst's speculation as a checkable fact. It is not a one-shot fact-checking prompt; it is a classification contract that runs before verification begins.
Prompt
Fact-Interpretation Separation System Prompt

When to Use This Prompt
A practical guide to deploying the Fact-Interpretation Separation System Prompt as a pre-processing contract in a verification pipeline.
Do not use this prompt when you need a final truth verdict on a claim, when the input is a single isolated sentence with no surrounding context, or when the operational latency budget cannot accommodate sentence-by-sentence classification. This prompt also underperforms on content where facts and interpretation are deliberately fused to mislead—adversarial blurring requires a separate detection step. The prompt assumes the input document contains discernible linguistic boundaries between fact and non-fact statements. If your source material is entirely speculative (e.g., a futurist essay) or entirely factual (e.g., a weather log), the classification output will be uniform and the computational cost may not be justified. In those cases, a simpler keyword-based or rule-based filter may suffice.
Before wiring this prompt into production, you must define the downstream consumer of its output. If the labeled sentences feed an evidence-matching system, ensure that system can handle the confidence and boundary_rationale fields without discarding them. If the output routes ambiguous cases to human reviewers, agree on a confidence threshold below which escalation occurs—typically, sentences scored below 0.7 confidence for the fact or interpretation labels are good candidates for review. The prompt includes eval checks for consistent classification across document types, but you should supplement these with your own golden dataset of 50–100 sentences labeled by domain experts. Measure inter-annotator agreement between the model and your experts before trusting the output in high-risk domains such as legal, financial, or medical content. In those domains, always route low-confidence outputs to a human and log the model's classification alongside the reviewer's final label for audit and continuous improvement.
Use Case Fit
Where the Fact-Interpretation Separation System Prompt delivers reliable classification and where it introduces risk. Use these cards to decide if this prompt fits your verification pipeline stage.
Good Fit: Pre-Processing for Verification Pipelines
Use when: You need a deterministic first pass to split content into fact and interpretation streams before evidence matching. The system prompt produces structured labels with confidence scores, making it ideal as a pipeline pre-processor that routes facts to verification and interpretation to human review. Guardrail: Validate boundary precision on a golden dataset before production; sentences blending facts and interpretation require special handling.
Bad Fit: Real-Time Chat or Consumer-Facing Output
Avoid when: The output is shown directly to end users without review. This prompt classifies content but does not verify truth; presenting labels as authoritative risks misleading users about what is confirmed versus merely classified. Guardrail: Use this prompt only in backend pipelines with downstream verification steps; never expose raw classification labels as truth badges in user interfaces.
Required Inputs: Source Content with Clear Provenance
What to watch: The prompt requires complete, attributed source content. Feeding it fragments, summaries, or content with unclear authorship degrades classification accuracy because the model cannot distinguish reported facts from the author's framing without context. Guardrail: Always include document type, author role, and publication context metadata alongside the content; test classification consistency when metadata is stripped.
Operational Risk: Confidence Score Over-Reliance
What to watch: Teams may treat the model's confidence scores as calibrated probabilities and auto-route low-confidence items without human review. These scores are ordinal rankings, not calibrated probabilities, and vary across document types and domains. Guardrail: Calibrate confidence thresholds per domain using human-annotated samples; implement a mandatory human review queue for all items below your validated threshold rather than trusting raw scores.
Operational Risk: Domain Shift Without Recalibration
What to watch: A prompt tuned on news articles will misclassify legal briefs, earnings calls, or medical summaries because each domain blends facts and interpretation differently. Legal argument often embeds facts within rhetorical sentences; financial forward-looking statements blur prediction and reported data. Guardrail: Maintain domain-specific eval sets and re-run classification accuracy tests whenever the input document type changes; use the domain-adapted variant prompts for specialized content.
Operational Risk: Adversarial Content Bypassing Classification
What to watch: Deliberately ambiguous content designed to blur fact and interpretation boundaries will produce low-confidence or inconsistent classifications. Adversarial inputs exploit the model's reluctance to commit when boundaries are intentionally obscured. Guardrail: Deploy the adversarial detection variant prompt as a secondary filter; route content flagged as intentionally ambiguous to human review regardless of confidence scores; log these cases for taxonomy improvement.
Copy-Ready Prompt Template
A reusable system-level instruction that classifies every sentence as fact, interpretation, opinion, prediction, or rhetorical framing with confidence scores and boundary rationales.
This system prompt is designed to be set once in the model's system instruction field and remain stable across multiple user messages, each containing a document to classify. It enforces a strict output schema, requires confidence scores for every classification, and demands boundary rationales when a single sentence contains multiple statement types. The prompt is self-contained: it defines the taxonomy, output format, and behavioral rules without relying on external context or conversation history.
textYou are a precise document classifier. Your only job is to classify every sentence in the provided document into exactly one of these five categories: 1. FACT: A verifiable statement that can be checked against external evidence. Facts are objective claims about observable reality, events, measurements, or documented statements. Examples: "The company reported $4.2B in revenue." "The bill was signed on March 12." 2. INTERPRETATION: An inference, analysis, or conclusion drawn from facts but not directly verifiable as a standalone statement. Interpretations apply reasoning to evidence. Examples: "This revenue decline suggests weakening demand." "The delay indicates resource constraints." 3. OPINION: A subjective judgment, preference, or value statement that cannot be resolved by evidence alone. Opinions express personal or organizational stance. Examples: "This was a poor decision." "The design is elegant." 4. PREDICTION: A forward-looking statement about future events, outcomes, or states. Predictions are not currently verifiable regardless of how confidently stated. Examples: "Revenue will grow 12% next quarter." "The regulation is likely to pass." 5. RHETORICAL_FRAMING: Language whose primary function is persuasion, emphasis, narrative construction, or emotional appeal rather than conveying checkable content. Examples: "We are at a crossroads." "This changes everything." RULES: - Classify every sentence independently. Do not let surrounding sentences influence a classification. - If a sentence contains multiple statement types, classify it as the dominant type AND include a boundary_rationale explaining which parts belong to which category. - Provide a confidence score from 0.0 to 1.0 for every classification. Use 0.0 for complete uncertainty and 1.0 for absolute certainty. - If confidence is below 0.7, include a specific reason in the confidence_note field. - Do not summarize, analyze, or comment on the document beyond the classification output. - Do not refuse to classify. If a sentence is ambiguous, classify it to the best of your ability with appropriately low confidence. OUTPUT FORMAT: Return a JSON object with this exact structure: { "classifications": [ { "sentence_index": 0, "text": "[EXACT_SENTENCE_TEXT]", "category": "[FACT|INTERPRETATION|OPINION|PREDICTION|RHETORICAL_FRAMING]", "confidence": [0.0-1.0], "confidence_note": "[REQUIRED_IF_CONFIDENCE_BELOW_0.7]", "boundary_rationale": "[REQUIRED_IF_MULTIPLE_TYPES_PRESENT]" } ] } [INPUT_DOCUMENT]
To adapt this prompt for your domain, modify the category definitions and examples to match your terminology. For legal documents, replace the generic examples with clause-level illustrations. For financial content, add domain-specific edge cases like distinguishing reported figures from adjusted measures. The output schema should remain stable; only the taxonomy descriptions and examples should change. Before deploying, run this prompt against a golden dataset of 50-100 sentences with known classifications and measure agreement against human labels. If agreement falls below 0.85 F1 on FACT vs. INTERPRETATION boundaries, add domain-specific few-shot examples to the category definitions rather than increasing instruction length.
Prompt Variables
Required and optional inputs for the Fact-Interpretation Separation System Prompt. 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 before execution.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[CONTENT] | The full text to classify sentence-by-sentence. Can be a document, transcript, article, or report section. | The company reported Q3 revenue of $4.2B, which we believe demonstrates strong execution in a challenging market. | Must be non-empty string. Check for minimum 1 sentence. If content exceeds model context window, split at paragraph boundaries and process in overlapping chunks with deduplication. |
[CLASSIFICATION_TAXONOMY] | The set of labels the model should assign to each sentence. Defines the output vocabulary for the separation task. | fact, interpretation, opinion, prediction, rhetorical_framing | Must be a non-empty list of unique string labels. Validate that taxonomy covers the required separation dimensions. If null, use default taxonomy. Each label must have a clear definition in the system prompt. |
[LABEL_DEFINITIONS] | Precise definitions for each classification label, including boundary rules and edge-case guidance. | fact: A statement that can be verified against external evidence without requiring judgment. interpretation: An inference or conclusion drawn from facts that requires analytical reasoning. | Must map 1:1 to [CLASSIFICATION_TAXONOMY] labels. Each definition must include verifiability criteria. Check for ambiguity between adjacent labels (e.g., interpretation vs opinion). If definitions are missing for any label, prompt should fail fast. |
[CONFIDENCE_THRESHOLD] | Minimum confidence score (0.0-1.0) required for automatic classification. Sentences below this threshold are routed to human review. | 0.85 | Must be a float between 0.0 and 1.0. If set below 0.7, expect higher false positive rate in production. If null, default to 0.8. Validate that downstream human review queue exists before lowering threshold. |
[OUTPUT_SCHEMA] | The expected JSON structure for each classified sentence, including required fields and their types. | { sentence_index: int, text: string, label: string, confidence: float, boundary_rationale: string } | Must be a valid JSON Schema or example object. Validate that all required fields are present: sentence identifier, original text, label, confidence score, and rationale. Check that label field accepts only values from [CLASSIFICATION_TAXONOMY]. |
[DOMAIN_CONTEXT] | Optional domain-specific guidance that adjusts classification boundaries for specialized terminology or evidence standards. | Financial domain: Reported figures are facts. Adjusted EBITDA is interpretation. Forward-looking statements are predictions. | If provided, must not contradict [LABEL_DEFINITIONS]. Check for domain-specific edge cases that override general rules. If null, model uses general-purpose classification. Validate that domain context is sourced from domain experts, not generated by another model without review. |
[FEW_SHOT_EXAMPLES] | Optional set of pre-classified sentences demonstrating correct label assignments, especially for boundary cases. | [{ text: 'Revenue grew 12% YoY.', label: 'fact', rationale: 'Verifiable against financial statements.' }, { text: 'This growth is impressive.', label: 'opinion', rationale: 'Evaluative language without external verifiability.' }] | If provided, must include at least 3 examples covering each label in [CLASSIFICATION_TAXONOMY]. Check that examples do not contradict [LABEL_DEFINITIONS]. Validate that examples include both clear cases and boundary cases. If null, model relies on definitions alone; expect lower accuracy on ambiguous sentences. |
[HUMAN_REVIEW_ROUTING] | Boolean flag indicating whether low-confidence classifications should be packaged for human review or returned with a flag. | Must be true or false. If true, output must include a review_packet field with the original sentence, model classification, confidence score, and specific questions for the reviewer. If false, low-confidence classifications are returned as-is with a low_confidence flag. Validate that human review queue endpoint exists before setting to true in production. |
Implementation Harness Notes
How to wire the Fact-Interpretation Separation System Prompt into a production verification pipeline with validation, retries, and human review routing.
This system prompt is designed as a reusable classification layer that sits between content ingestion and downstream verification. It expects raw text input and returns structured labels for every sentence. In production, you'll typically deploy this as a pre-processing step: raw documents flow in, the model classifies each sentence as fact, interpretation, opinion, prediction, or rhetorical framing, and only sentences tagged as 'fact' proceed to evidence matching and claim verification. Sentences tagged as interpretation, opinion, or prediction should be routed to separate analysis pipelines or flagged for human review rather than being silently treated as verifiable claims.
Wire the prompt into your application by constructing a request that combines this system instruction with the target document as user input. Use a model that supports structured output with a defined JSON schema matching the expected output shape: an array of sentence objects, each containing sentence_index, text, classification, confidence, and boundary_rationale. Implement a validation layer that checks for schema compliance, missing fields, confidence scores below your threshold (typically 0.7 for auto-routing), and sentences where the model flags boundary ambiguity. For high-stakes domains like legal or medical content, set a stricter confidence floor (0.85+) and route anything below it to human review. Log every classification decision with the model version, prompt hash, input document identifier, and timestamp for audit trails.
Build retry logic for malformed outputs: if the response fails schema validation, retry once with the same prompt and a stronger constraint instruction appended. If the second attempt fails, escalate the entire document to a human review queue rather than silently dropping sentences. For batch processing, implement parallel requests with a concurrency limit appropriate to your rate limits, and include a post-processing step that checks for cross-document classification consistency using the eval rubric from the companion Fact-Interpretation Separation Eval Rubric Prompt. Avoid wiring this prompt directly into user-facing features without a human-in-the-loop fallback—misclassifying an interpretation as a fact can cascade into false verification results downstream. Start with a shadow mode deployment where classifications are logged and compared against human labels before enabling automated routing.
Expected Output Contract
Defines the structured JSON output schema for the Fact-Interpretation Separation System Prompt. Use this contract to validate model responses before they enter downstream verification pipelines.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
classification_result.sentences | Array of objects | Array must not be empty. Each object must contain sentence_index, text, label, confidence, and boundary_rationale fields. | |
classification_result.sentences[].sentence_index | Integer | Must be a zero-based sequential index matching the order of input sentences. No gaps or duplicates allowed. | |
classification_result.sentences[].text | String | Must exactly match the original sentence text from the input. Any deviation triggers a string equality check failure. | |
classification_result.sentences[].label | Enum: fact | interpretation | opinion | prediction | rhetorical_framing | Must be one of the five allowed enum values. Case-sensitive. No custom or extended labels permitted. | |
classification_result.sentences[].confidence | Float between 0.0 and 1.0 | Must be a valid float. Values below [CONFIDENCE_THRESHOLD] should route to human review. Null not allowed. | |
classification_result.sentences[].boundary_rationale | String | Must contain a non-empty explanation referencing specific linguistic markers, evidence basis, or structural cues that justify the label choice. | |
classification_result.summary.total_sentences | Integer | Must equal the length of the sentences array. Mismatch indicates a processing error or truncation. | |
classification_result.summary.label_distribution | Object with keys matching label enum values | Values must be integers summing to total_sentences. Missing keys for unused labels should default to 0. |
Common Failure Modes
Fact-interpretation separation is a classification task with inherently fuzzy boundaries. These failure modes emerge in production when the model encounters ambiguous language, domain-specific framing, or adversarial blurring. Each card pairs a specific failure with a concrete guardrail you can implement before deployment.
Interpretation Disguised as Fact
What to watch: The model classifies analytical language, characterizations, or implied conclusions as factual statements. This happens most often with authoritative-sounding passive constructions ('it was determined that') and nominalizations that hide agency ('the failure resulted from'). Guardrail: Add few-shot examples showing near-miss cases where confident-sounding language is actually interpretation. Require the model to identify the specific verifiable observation underlying any claimed fact, and flag statements where no such observation exists.
Boundary Collapse in Compound Sentences
What to watch: A single sentence containing both a factual claim and an interpretive layer gets classified entirely as one type. The model defaults to the dominant clause and loses the embedded fact or interpretation. Guardrail: Add a pre-processing step that splits compound sentences on clause boundaries before classification. In the system prompt, explicitly instruct the model to flag sentences containing mixed types and produce per-clause labels rather than a single sentence-level tag.
Domain Terminology Confusion
What to watch: Domain-specific terms that carry both factual and interpretive weight in context (e.g., 'material weakness' in audit reports, 'clinically significant' in medical notes) are misclassified because the model lacks the domain frame. Guardrail: Provide a domain-specific glossary in the system prompt that maps contested terms to their default classification with boundary rules. Include a confidence downgrade instruction when domain terms appear without sufficient surrounding context to resolve their status.
Confidence Miscalibration on Hedged Language
What to watch: The model assigns high confidence to fact classifications when the source text contains hedging ('appears to indicate,' 'suggests,' 'may reflect') that should lower certainty. The surface form of a factual claim overrides the hedging signal. Guardrail: Add explicit hedging-detection rules in the system prompt that trigger automatic confidence reduction. Create a hedging lexicon and instruct the model to check for these terms before assigning confidence scores above 0.7 to any factual classification.
Rhetorical Framing Misclassified as Prediction
What to watch: Rhetorical devices that use future-tense or conditional language for persuasive effect ('this will inevitably lead to,' 'any reasonable observer would conclude') get classified as predictions rather than rhetorical framing. Guardrail: Add a classification priority rule: when a statement uses future-tense language but serves a persuasive or framing function rather than making a testable forecast, it should default to rhetorical framing. Include examples of rhetorical future-tense versus genuine predictions in few-shot demonstrations.
Adversarial Blurring Evasion
What to watch: Content deliberately constructed to blur fact and interpretation boundaries—such as embedding factual claims inside opinion statements or using weasel words to create plausible deniability—passes through classification without flagging. Guardrail: Add an adversarial detection layer that flags passages where fact-interpretation boundaries are intentionally obscured. Instruct the model to mark such passages as 'boundary unreliable' and escalate to human review rather than forcing a classification. Include adversarial examples in your eval harness to measure recall on known blurring patterns.
Evaluation Rubric
Use this rubric to test the Fact-Interpretation Separation System Prompt before shipping. Each criterion targets a known failure mode in production classification pipelines. Run these checks against a golden dataset of 50-100 mixed-content passages with expert human labels as ground truth.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Boundary Precision | Fact and interpretation spans within the same sentence are correctly split with non-overlapping character offsets | Merged spans where a single span contains both a verifiable claim and an interpretive modifier | Compare span offsets against human-annotated boundaries; measure Intersection-over-Union (IoU) per span pair |
Type Classification Accuracy | Overall F1 score >= 0.85 across all five types (fact, interpretation, opinion, prediction, rhetorical) against expert labels | Confusion matrix shows fact misclassified as interpretation or opinion misclassified as rhetorical above 15% error rate | Run stratified evaluation with 20 samples per type; compute per-class precision, recall, and F1 |
Confidence Calibration | Confidence scores correlate with actual correctness: high-confidence predictions (>0.9) are correct >= 90% of the time | High-confidence predictions are wrong more than 10% of the time, or low-confidence predictions (<0.5) are correct more than 50% of the time | Bucket predictions by confidence decile; plot expected calibration error (ECE) curve against ground truth |
Boundary Rationale Quality | Every boundary decision includes a rationale that references specific linguistic markers (hedging verbs, attribution phrases, modal auxiliaries) | Rationales are generic (e.g., 'this is interpretation') without citing the actual text signal that triggered the classification | Spot-check 30 rationales; require at least 80% to contain a quoted text fragment or named linguistic pattern from the source |
Cross-Document Consistency | Same sentence structure classified consistently across different documents with <10% type-switching rate | Identical or near-identical phrasing receives different type labels across documents without a defensible context difference | Insert 10 duplicate or near-duplicate sentences across the test set; measure type-label agreement rate |
Adversarial Blurring Detection | Prompt flags >= 80% of deliberately ambiguous passages where fact and interpretation are intentionally blended | Adversarial passages receive high-confidence single-type labels instead of being flagged as ambiguous or split with low confidence | Use a held-out adversarial set of 25 passages crafted to blur boundaries; measure flag rate and false-negative rate |
Null Handling | Empty input, whitespace-only input, or input with no classifiable content returns an empty array with no errors | Prompt hallucinates classifications for empty input or returns a non-empty array with fabricated content | Send empty string, newline-only string, and a string with only punctuation; assert output array length is 0 |
Inter-Annotator Agreement Alignment | Model classifications agree with human majority label at a rate within 10% of human-human agreement on the same dataset | Model agreement with humans is significantly lower than human-human agreement baseline, indicating the prompt is not capturing expert judgment | Compute Cohen's kappa between model and each human annotator; compare to pairwise human kappa distribution |
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
Start with the base system prompt and a small test set of 20–30 sentences covering clear facts, clear opinions, and ambiguous cases. Run classification without confidence thresholds or schema enforcement. Focus on whether the model consistently distinguishes fact from interpretation before adding pipeline complexity.
Watch for
- Over-classifying predictions as facts when they contain hedging language like 'may,' 'could,' or 'expected'
- Missing rhetorical framing that presents opinion as objective observation
- Inconsistent labels on the same sentence type across runs

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