This prompt is designed for intelligence analysts, knowledge graph engineers, and data pipeline operators who need to distinguish factual events from hypothetical, planned, negated, or uncertain ones in unstructured text. The core job is to assign a factuality label, a modality marker, and a polarity flag to every extracted event, ensuring that downstream systems do not treat a canceled meeting or a speculative forecast as an established fact. Use this when your ingestion pipeline feeds a timeline, a graph database, or an alerting system where false positives from non-factual events carry high operational cost.
Prompt
Event Factuality Assessment Prompt Template

When to Use This Prompt
Defines the job, ideal user, required inputs, and clear boundaries for the Event Factuality Assessment prompt.
The prompt requires a pre-extracted event structure as input—typically the output of an event extraction step that already identifies the event trigger, arguments, and source span. You must supply the event text, its surrounding context, and any known document metadata. The template is not a general-purpose fact-checker for arbitrary claims; it assumes you have already isolated candidate events and now need to assess their factuality status. Do not use this prompt on raw, unprocessed documents or as a standalone veracity classifier without event extraction upstream.
Before wiring this into production, define your factuality taxonomy explicitly. The prompt uses labels such as FACTUAL, HYPOTHETICAL, PLANNED, NEGATED, and UNCERTAIN, but your downstream schema may require a different set. Adapt the [FACTUALITY_LABELS] placeholder to match your ontology. Also plan for human review on UNCERTAIN or conflicting signals—this workflow is high-risk when ingested events trigger automated actions. The next section provides the copy-ready template you can adapt and test against your own event corpus.
Use Case Fit
Where the Event Factuality Assessment Prompt Template delivers reliable signal—and where it introduces risk that requires a different approach or additional safeguards.
Good Fit: Intelligence Analysis Reports
Use when: analysts need to distinguish confirmed events from planned operations, hypothetical scenarios, or negated claims in narrative reports. Guardrail: pair the prompt with source attribution to anchor every factuality label to its evidence span.
Good Fit: News Verification Pipelines
Use when: ingesting news articles and flagging reported events as factual, alleged, or denied before downstream consumption. Guardrail: implement a confidence threshold below which articles route to human review rather than automatic publication.
Bad Fit: Real-Time Social Media Monitoring
Avoid when: processing high-velocity, low-context social posts where hedging language and sarcasm dominate. Guardrail: use a lightweight triage classifier first; reserve full factuality assessment for posts that clear a minimum context threshold.
Bad Fit: Legal Verdict or Regulatory Determination
Avoid when: the output could be interpreted as an official finding of fact in legal, compliance, or regulatory contexts. Guardrail: add a mandatory disclaimer layer and require human attorney review before any factuality label enters a system of record.
Required Inputs
What you need: a complete source text span with surrounding context, a defined event taxonomy, and polarity/modality labels your downstream system can consume. Guardrail: validate that every input includes enough context to resolve anaphora and implicit negation before assessment.
Operational Risk: Counterfactual Confusion
What to watch: the model may label counterfactual or hypothetical events as factual when the conditional structure is subtle. Guardrail: add explicit counterfactual detection checks in post-processing and escalate any event with mixed modality signals to human review.
Copy-Ready Prompt Template
A reusable prompt template for assessing the factuality of events extracted from text, distinguishing factual claims from hypothetical, planned, or negated ones.
The following prompt template is designed to be copied directly into your AI harness. It takes an extracted event and its surrounding context as input and returns a structured factuality assessment. The template uses square-bracket placeholders for all dynamic inputs, making it easy to parameterize in code. Before using this prompt in production, you must define your [FACTUALITY_LABELS] taxonomy, prepare representative [FEW_SHOT_EXAMPLES], and decide on the [OUTPUT_SCHEMA] that your downstream ingestion pipeline expects.
textYou are an expert linguistic analyst specializing in event factuality assessment. Your task is to analyze an event extracted from a source text and determine its factuality status. ## INPUT **Source Text:** [SOURCE_TEXT] **Extracted Event:** [EXTRACTED_EVENT] **Surrounding Context (3 sentences before and after):** [SURROUNDING_CONTEXT] ## TASK Analyze the extracted event and assign a factuality label from the taxonomy below. Consider hedging language, modal verbs, negation, conditional structures, future tense, and counterfactual markers. ## FACTUALITY TAXONOMY [FACTUALITY_LABELS] ## OUTPUT SCHEMA Return a single JSON object matching this schema: [OUTPUT_SCHEMA] ## CONSTRAINTS - Base your assessment ONLY on the provided source text and context. Do not use external knowledge. - If the event's factuality is ambiguous, set the confidence score low and explain the ambiguity in the `evidence_rationale` field. - Flag any hedging language, modal verbs, or negation cues in the `linguistic_markers` array. - If the event is negated, set the `polarity` field to "negative" and explain what is being denied. - If the event is hypothetical or conditional, identify the condition in the `modality_trigger` field. ## EXAMPLES [FEW_SHOT_EXAMPLES] ## RISK LEVEL [RISK_LEVEL]
To adapt this template for your use case, start by defining your factuality taxonomy. A minimal taxonomy might include factual, probable, planned, hypothetical, negated, and counterfactual. For intelligence or legal workflows, you may need finer-grained distinctions such as reported_by_source versus directly_observed. The [FEW_SHOT_EXAMPLES] placeholder is critical for model performance—include at least one example per factuality label, with clear linguistic markers highlighted. If your risk level is high, add an instruction for the model to abstain and return "factuality": "uncertain" with a confidence score below a defined threshold, triggering human review in your harness.
After copying this template, wire it into your application with a validation layer that checks for schema compliance, missing required fields, and confidence scores below your operational threshold. For high-stakes domains like intelligence analysis or legal review, always route low-confidence assessments to a human review queue. Test the prompt against a golden dataset of 50–100 annotated examples covering all factuality labels, including edge cases with nested hedging, double negation, and mixed modality signals.
Prompt Variables
Required and optional inputs for the Event Factuality Assessment 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 |
|---|---|---|---|
[SOURCE_TEXT] | The raw narrative text containing events to assess for factuality | The company announced it will launch the product next quarter, pending regulatory approval. | Must be non-empty string. Check length < model context window minus prompt overhead. Reject if only whitespace. |
[EVENT_DESCRIPTION] | A short natural-language description of the specific event to assess within the source text | Company launching product next quarter | Must be non-empty string. Should be extractable from [SOURCE_TEXT]. Warn if substring match fails or cosine similarity to any sentence is below 0.3. |
[ASSESSMENT_CRITERIA] | A list of factuality dimensions to evaluate, such as asserted, planned, hypothetical, negated, or counterfactual | Asserted events only; exclude planned and hypothetical | Must be a non-empty list of valid factuality labels. Validate against allowed enum: asserted, planned, hypothetical, negated, counterfactual, conditional, reported, uncertain. Reject unknown labels. |
[MODALITY_MARKERS] | Optional list of hedging or modal language patterns to detect, such as 'might', 'could', 'if', 'unless' | might, could, if, unless, subject to, pending | Can be null or empty array. If provided, each entry must be a non-empty string. Warn if marker list exceeds 50 entries to avoid prompt bloat. |
[POLARITY_FLAGS] | Optional boolean flags to toggle detection of negation and counterfactual signals | detect_negation: true, detect_counterfactual: true | Can be null. If provided, must be a valid JSON object with boolean values for known keys. Reject if non-boolean values present. |
[OUTPUT_SCHEMA] | The expected JSON schema for the factuality assessment output | {"event": "string", "factuality_label": "string", "modality_markers_found": ["string"], "polarity": "string", "confidence": "number", "evidence_span": "string"} | Must be a valid JSON Schema object or a concise structural example. Parse check before prompt assembly. Reject if schema contains circular references. |
[FEW_SHOT_EXAMPLES] | Optional array of input-output pairs demonstrating correct factuality assessment | [{"input": "We might expand to Europe.", "output": {"factuality_label": "hypothetical", "modality_markers_found": ["might"], "polarity": "positive", "confidence": 0.9}}] | Can be null or empty array. If provided, each example must have 'input' and 'output' keys. Validate output matches [OUTPUT_SCHEMA]. Limit to 3-5 examples to control token usage. |
[CONFIDENCE_THRESHOLD] | Minimum confidence score required for automated acceptance; scores below trigger human review | 0.75 | Must be a float between 0.0 and 1.0 inclusive. Default to 0.7 if null. Reject values outside range. Used downstream, not inside the prompt itself. |
Implementation Harness Notes
How to wire the Event Factuality Assessment prompt into a production application with validation, retries, logging, and human review gates.
The Event Factuality Assessment prompt is designed to sit inside a document processing pipeline where raw text has already been segmented into candidate event spans. Before calling the prompt, your application should extract the sentence or paragraph containing the event claim, along with surrounding context (typically ±2 sentences). The prompt expects a structured [INPUT] containing the event text, a [CONTEXT] window, and an optional [OUTPUT_SCHEMA] defining the factuality labels your downstream system expects. Do not send entire documents; the model performs best when the event span is isolated with just enough context to resolve pronouns, temporal references, and discourse markers.
Wire the prompt into an application harness that enforces a strict JSON output contract. After receiving the model response, validate that every required field is present: factuality_label must be one of your defined enum values (e.g., factual, hypothetical, planned, negated, counterfactual), modality_markers must be a non-empty array of strings extracted from the source text, and polarity must be either positive or negative. If validation fails, implement a single retry with the validation error message appended to the prompt as a [CONSTRAINTS] amendment. After two failures, route the event to a human review queue rather than looping indefinitely. Log every assessment with the model version, prompt template hash, raw response, validation result, and reviewer decision for auditability.
For high-stakes domains—intelligence analysis, legal fact extraction, financial event processing—never treat the model's factuality label as ground truth without human confirmation. Implement a confidence threshold: if the model's response includes a confidence field below your defined cutoff (typically 0.85 for automated acceptance), or if the modality_markers contain hedging terms like 'allegedly,' 'reportedly,' or 'may have,' escalate to human review. Store the original source spans alongside the assessment so reviewers can quickly verify the model's judgment against the raw text. Avoid using this prompt for real-time decision systems where a misclassified counterfactual could trigger an automated action; the modality detection is strong but not infallible on edge cases involving sarcasm, implicit negation, or culturally specific hedging patterns.
Expected Output Contract
Defines the exact shape, types, and validation rules for the JSON object returned by the Event Factuality Assessment prompt. Use this contract to build a parser, validator, or ingestion adapter before processing model output.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
event_id | string | Must match the [INPUT_EVENT_ID] from the request. Reject if missing or mismatched. | |
factuality_label | enum: factual | planned | hypothetical | negated | counterfactual | uncertain | Must be exactly one of the allowed enum values. Reject any other string. | |
modality_markers | array of strings | Each element must be a non-empty string. Allow empty array only if factuality_label is factual. Reject if null. | |
polarity_flag | enum: positive | negative | Must be positive or negative. Reject if missing or any other value. | |
hedging_detected | boolean | Must be true or false. Reject if null, string, or number. | |
confidence_score | number | Must be a float between 0.0 and 1.0 inclusive. Reject if outside range, null, or non-numeric. | |
evidence_spans | array of objects with fields: text (string), start_char (integer), end_char (integer) | Each object must have non-empty text and valid integer offsets. Reject if array is empty for non-factual labels. Reject if offsets are negative or out of bounds. | |
counterfactual_trigger | string or null | If factuality_label is counterfactual, this field must be a non-empty string. Otherwise, must be null. Reject if constraint violated. |
Common Failure Modes
Factuality assessment prompts fail in predictable ways. Here are the most common failure modes and how to guard against them before they reach production.
Modality Confusion: Hypothetical vs. Actual
What to watch: The model conflates planned events, conditional statements, and hypothetical scenarios with factual occurrences. Language like 'would have,' 'plans to,' or 'if approved' gets labeled as FACTUAL. Guardrail: Include explicit modality definitions with contrastive few-shot examples. Add a post-extraction check that scans for hedging markers (would, could, might, plans, expects, intends) and flags any FACTUAL label on a sentence containing them for human review.
Polarity Negation Blindness
What to watch: The model misses negation cues ('did not occur,' 'failed to,' 'denied') and labels negated events as positive occurrences. Double negatives and scope ambiguity ('not all attendees agreed') are especially brittle. Guardrail: Require a separate polarity flag in the output schema. Add validation that checks for negation words in the source span and verifies the polarity flag matches. Use few-shot examples with explicit negation patterns including 'never,' 'no longer,' and 'contrary to reports.'
Source Attribution Collapse
What to watch: The model treats reported speech as direct fact. When a source says 'The CEO claimed revenue grew,' the model labels revenue growth as FACTUAL rather than REPORTED. Guardrail: Require a source attribution field distinguishing first-hand observation from hearsay. Add a validation rule: if the source span contains reporting verbs (said, claimed, stated, according to), the factuality label must be REPORTED or ATTRIBUTED, never FACTUAL without corroboration.
Temporal Scope Overreach
What to watch: The model assigns present-tense certainty to future events or past-tense certainty to ongoing situations. 'The company is expanding' gets labeled FACTUAL when it describes an announced plan, not a completed action. Guardrail: Include a temporal grounding field (past/present/future/ongoing) in the output schema. Cross-validate: if temporal grounding is FUTURE, factuality cannot be FACTUAL. Add few-shot examples showing future-tense statements correctly labeled as PLANNED or PROJECTED.
Confidence Overstatement on Ambiguous Evidence
What to watch: The model assigns high confidence to factuality labels when the source text contains conflicting signals, vague language, or incomplete information. 'Sources suggest a deal may be close' gets HIGH confidence instead of LOW or MEDIUM. Guardrail: Require explicit confidence scoring with evidence strength justification. Add a calibration check: if the source span contains uncertainty markers (may, might, sources suggest, unclear, reportedly), cap confidence at MEDIUM and flag for human review if the event is high-stakes.
Counterfactual Misclassification
What to watch: The model fails to detect counterfactual constructions ('If the deal had closed,' 'Had the policy been enacted') and labels them as factual or hypothetical rather than COUNTERFACTUAL. Guardrail: Add a dedicated COUNTERFACTUAL label in the factuality taxonomy. Include few-shot examples with counterfactual grammar patterns (past perfect in if-clauses, 'would have' + past participle). Add a regex pre-check for counterfactual syntactic markers before model inference.
Evaluation Rubric
Use this rubric to test the Event Factuality Assessment prompt before shipping. Each criterion targets a known failure mode in modality, polarity, and hedging detection.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Factual Event Detection | Output label is 'factual' for events described with indicative mood, past tense, and no hedging or negation. | Label is 'planned', 'hypothetical', or 'negated' for a clearly asserted past event. | Run against 20 gold factual sentences from news reports; require >= 90% 'factual' recall. |
Planned Event Detection | Output label is 'planned' for future events with scheduling language (e.g., 'will', 'scheduled to', 'on [DATE]'). | Label is 'factual' for a future event with no completion evidence. | Run against 20 gold planned sentences from meeting notes and press releases; require >= 85% 'planned' recall. |
Hypothetical Event Detection | Output label is 'hypothetical' for conditional, subjunctive, or speculative constructions (e.g., 'if', 'could', 'might', 'would have'). | Label is 'factual' for a conditional statement. | Run against 20 gold hypothetical sentences from analyst reports; require >= 85% 'hypothetical' recall. |
Negated Event Detection | Polarity flag is 'negative' and label is 'negated' for explicit negation (e.g., 'did not', 'failed to', 'no [EVENT] occurred'). | Polarity flag is 'positive' for a negated event. | Run against 20 gold negated sentences; require >= 90% 'negated' recall and correct polarity flag. |
Hedging Language Flagging | Modality marker is set to 'hedged' when epistemic qualifiers are present (e.g., 'allegedly', 'reportedly', 'it appears that'). | Modality marker is 'asserted' for a sentence containing 'allegedly'. | Run against 15 gold hedged sentences; require >= 80% 'hedged' modality marker recall. |
Counterfactual Detection | Output label is 'counterfactual' for past conditional constructions (e.g., 'would have [EVENT] if', 'had [EVENT] occurred'). | Label is 'hypothetical' or 'negated' for a clear counterfactual. | Run against 15 gold counterfactual sentences; require >= 80% 'counterfactual' recall. |
Schema Compliance | Output is valid JSON matching the [OUTPUT_SCHEMA] with all required fields present and correct types. | Missing 'factuality_label', 'polarity', or 'modality' fields; string where boolean expected. | Validate output with JSON Schema validator; require 100% structural compliance across 50 test cases. |
Null Handling for Ambiguous Input | Confidence score is below [CONFIDENCE_THRESHOLD] and 'factuality_label' is 'ambiguous' when event status cannot be determined. | High confidence score assigned to genuinely ambiguous input. | Run against 10 ambiguous sentences (mixed signals); require 'ambiguous' label and confidence < 0.7 for all. |
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 prompt and a simple JSON schema. Use a single model call without retries or validation. Focus on getting the factuality labels (factual, hypothetical, planned, negated, counterfactual) and polarity flags correct on a small sample set.
code[SYSTEM]: You are an event factuality assessor. Given [INPUT_TEXT], classify each event as factual, hypothetical, planned, negated, or counterfactual. Return JSON with `events` array, each containing `event_text`, `factuality`, `polarity`, and `modality_markers`.
Watch for
- Model conflating
plannedwithhypotheticalwhen future markers are ambiguous - Missing
negatedevents entirely when negation is implicit - Overly broad
modality_markersthat capture hedging language not tied to a specific event

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