Evidence Chain-of-Thought Grounding Prompt

This prompt is built for workflows where a wrong answer is expensive and an unexplainable answer is unacceptable. The ideal user is a document intelligence team, legal reviewer, financial auditor, or clinical analyst who needs to see exactly how the model moved from evidence to conclusion. The required context is a set of source documents or retrieved passages that the model can cite. Without that evidence, the prompt will force the model to abstain rather than invent support, which is the correct behavior for this use case but a frustrating one for casual Q&A.

Do not use this prompt for fast, conversational interactions or for tasks where the answer matters more than the reasoning. It is a poor fit for creative writing, open-ended brainstorming, or low-stakes classification where latency and token cost outweigh traceability. It is also not a replacement for a RAG pipeline; you must supply the evidence passages. The prompt assumes you have already retrieved candidate sources and now need the model to reason over them transparently. If your retrieval is weak, the model will surface evidence gaps rather than paper over them, which is a feature for audit teams but a failure mode if you expected fluent answers from thin context.

Before deploying, pair this prompt with an evaluation harness that checks citation accuracy, reasoning-gap detection, and abstention correctness. In regulated domains, always route outputs through human review before they become decisions. The next section provides the copy-ready template you can adapt to your evidence format and output schema.

This prompt template is designed for audit and review workflows where reasoning transparency is non-negotiable. It forces the model to externalize its chain of thought, making every logical step explicit and grounding each one in a specific, cited source passage. The primary job-to-be-done is generating an output where a human reviewer can trace the conclusion back to the evidence without guessing how the model got there. Use this when you need a verifiable reasoning trace for compliance, legal review, or high-trust decision support. Do not use this for latency-sensitive chat applications where the verbosity of a full trace would degrade the user experience; a simpler RAG citation prompt is more appropriate for those cases.

textCopy
You are an expert analyst. Your task is to answer the user's question by following a strict, step-by-step reasoning process. You must cite the specific source passage that justifies each inferential step.

## INPUT
**Question:** [USER_QUESTION]
**Sources:**
[SOURCES]

## OUTPUT FORMAT
Your entire response must be a single JSON object conforming to this schema:
{
  "final_answer": "string",
  "reasoning_trace": [
    {
      "step_number": "integer",
      "thought": "string (the logical step you are taking)",
      "conclusion": "string (the partial conclusion reached in this step)",
      "source_citation": "string (the exact text from the provided sources that supports this step, or 'No source available' if it is a purely logical deduction)",
      "source_id": "string (the ID of the source document, or null)"
    }
  ],
  "evidence_gaps": [
    "string (describe any part of the question that could not be answered from the sources)"
  ]
}

## CONSTRAINTS
1. **Mandatory Citations:** Every step in the `reasoning_trace` that uses factual information from the sources MUST include a verbatim quote in the `source_citation` field and the corresponding `source_id`. Do not paraphrase the citation.
2. **No Hallucination:** If a logical step cannot be supported by the provided sources, you must state 'No source available' in the `source_citation` field. Do not invent facts.
3. **Step-by-Step Logic:** Break down your reasoning into the smallest possible logical units. Do not skip steps. The `thought` field should explain *why* you are taking the step, and the `conclusion` field should state the *result* of that step.
4. **Gap Analysis:** After your reasoning trace, explicitly list any parts of the `final_answer` or the user's question that could not be fully supported by the evidence in the `evidence_gaps` array. If there are no gaps, return an empty array.
5. **JSON Only:** Your response must be valid, parseable JSON. Do not include any text outside the JSON object.

To adapt this template, replace the [USER_QUESTION] and [SOURCES] placeholders. The [SOURCES] placeholder should be filled with a pre-formatted string of your retrieved documents, each clearly labeled with a unique source_id (e.g., [DOC_ID_1]: ...). The strict JSON output contract makes this prompt ideal for direct integration into an application pipeline. Before deploying, validate the model's output against the schema and run evaluations that specifically check for citation accuracy and reasoning trace completeness. For high-risk domains, always route outputs with non-empty evidence_gaps arrays or null source_ids for factual claims to a human review queue.

This prompt is designed to be the reasoning layer between retrieval and final answer generation. In production, assemble the prompt with validated source passages, call the model, parse the reasoning chain, and validate that every inferential step cites at least one source. The reasoning chain itself becomes a first-class output artifact, not just an intermediate throwaway. Store it alongside the final answer for downstream audit, review, and debugging workflows.

Implement a two-pass architecture for high-trust deployments. The first pass generates the reasoning chain with citations using the prompt template. The second pass validates citation accuracy by extracting each cited passage from the original sources and checking that the claim in the reasoning step is actually supported by the cited text. Flag any step where the cited passage does not contain the claimed information or where a reasoning step lacks a citation entirely. If validation fails, retry the first pass with a stricter instruction appended to the prompt, such as 'Every reasoning step MUST include a verbatim quote from the cited source that directly supports the claim.' After three failed retries, escalate to human review with the full trace attached.

Log the complete reasoning trace, source passages, model version, prompt template version, and validation results as an immutable audit record. For regulated domains, store this record in a write-once data store with a hash chain or timestamped entry. Include a structured metadata block with fields like reasoning_step_count, citation_coverage_score, validation_pass, and human_review_required. Wire the output into your application by extracting the final conclusion from the reasoning chain and presenting it alongside a collapsible or expandable reasoning trace in the UI. Never surface the raw reasoning chain to end users without first running the validation pass to catch hallucinated citations before they become visible.

Model choice matters here. Use models with strong instruction-following and long-context reasoning capabilities. If using a smaller or faster model for cost reasons, increase the retry budget and lower the threshold for human escalation. For tool-augmented setups, consider giving the model a cite_source tool that accepts a source ID and quote string, enforcing structured citation at the tool-call level rather than relying solely on text-format instructions. This reduces parsing fragility and makes validation deterministic.