Cross-Source Corroboration Scoring Prompt

This prompt is designed for evidence pipelines that must measure how consistently a specific claim is supported across multiple independent sources. The primary job-to-be-done is scoring corroboration strength to distinguish well-supported facts from isolated assertions. The ideal user is an AI platform engineer, a trust-and-safety engineer, or a RAG pipeline architect who needs to programmatically detect echo chambers, flag single-source claims, and prevent the model from treating a single loud source as consensus. The required context includes a target claim and a set of source passages, each with enough metadata (e.g., publisher, date) to allow independence checks.

Use this prompt when your application generates factual claims and you need to verify them against a retrieval corpus before showing them to a user. It is appropriate for research synthesis, due diligence, news monitoring, and any high-stakes domain where a claim's credibility depends on multi-source agreement. The prompt is not a fact-checker for objective truth; it scores agreement patterns. Do not use it when you have only one source, when sources are not independent (e.g., all syndicated from the same wire service), or when the claim is subjective opinion. In regulated or high-risk domains, the output is a signal for a human reviewer or a downstream weighting algorithm, not a final publish/discard decision.

Before implementing, map out your source independence criteria. The prompt's value collapses if it cannot distinguish between original reporting and circular referencing. Plan to pair this prompt with a source trustworthiness assessment from the same pillar to ensure you are scoring corroboration among authoritative sources, not just any sources. The next section provides the copy-ready template.

This section provides the core prompt template for cross-source corroboration scoring. The template is designed to be copied directly into your application code, test harness, or prompt management system. It accepts a target claim and a set of source passages, then returns a structured corroboration score along with detailed evidence of agreement, disagreement, and echo-chamber detection. Every placeholder is enclosed in square brackets and must be populated by your application layer before the prompt is sent to the model.

textCopy
You are an evidence corroboration analyst. Your task is to evaluate how consistently a claim is supported across multiple independent sources.

## INPUT
**Claim to evaluate:** [CLAIM]

**Source passages:**
[SOURCE_PASSAGES]

## INSTRUCTIONS
1. For each source passage, determine whether it supports, contradicts, or is neutral toward the claim.
2. Identify which sources are likely independent versus those that appear to reference or reproduce each other (echo-chamber detection).
3. Assign a corroboration score from 0.0 to 1.0 where:
   - 1.0 = Multiple independent sources strongly and consistently support the claim
   - 0.7-0.9 = General agreement with minor variation across independent sources
   - 0.4-0.6 = Mixed support or heavy dependence on a single source
   - 0.1-0.3 = Mostly contradictory or only one weak source supports the claim
   - 0.0 = No source supports the claim or all sources contradict it
4. Flag any claim that relies on only a single source or a cluster of non-independent sources.

## OUTPUT SCHEMA
Return a JSON object with this exact structure:
{
  "corroboration_score": <float 0.0-1.0>,
  "score_confidence": <float 0.0-1.0>,
  "independent_source_count": <integer>,
  "total_source_count": <integer>,
  "supporting_sources": [<list of source identifiers>],
  "contradicting_sources": [<list of source identifiers>],
  "neutral_sources": [<list of source identifiers>],
  "echo_chamber_detected": <boolean>,
  "echo_chamber_detail": <string explanation if detected, otherwise null>,
  "single_source_dependency": <boolean>,
  "assessment_summary": <string 2-4 sentence summary of findings>,
  "uncertainty_factors": [<list of strings describing factors that reduce confidence>]
}

## CONSTRAINTS
- Do not invent evidence not present in the provided source passages.
- If sources disagree, report the disagreement rather than averaging into a misleading score.
- Treat sources that cite each other or share identical phrasing as potentially non-independent.
- If publication dates are provided, note whether older sources may have been superseded.
- If fewer than 2 independent sources exist, set single_source_dependency to true and reduce the corroboration score accordingly.
- Do not evaluate the truth of the claim itself, only the degree of source agreement.

## RISK LEVEL
[RISK_LEVEL]

Adaptation guidance: Replace [CLAIM] with the statement under evaluation, formatted as a single sentence when possible. Populate [SOURCE_PASSAGES] with a structured list of source objects, each containing at minimum an identifier, the passage text, and optionally a publication date and source type. The [RISK_LEVEL] placeholder should be set to high, medium, or low based on your application's tolerance for error. At high risk levels, add an instruction requiring the model to abstain from scoring when fewer than two independent sources are available, and route the output for human review before any downstream action. For production pipelines, validate the output JSON against the schema before accepting the score, and log any parse failures for prompt refinement.

The Cross-Source Corroboration Scoring Prompt is designed to sit between retrieval and answer generation in a RAG pipeline. After you retrieve passages that support or refute a claim, this prompt scores how consistently the claim is supported across independent sources. The output is a structured corroboration score, an independence assessment, and a flag for single-source or echo-chamber patterns. Wire this prompt as a post-retrieval, pre-synthesis step: the retrieval system returns candidate evidence, this prompt scores corroboration, and the downstream answer generator uses the score to decide how much confidence to express or whether to refuse the claim entirely.

For a production implementation, wrap the prompt in a function that accepts a claim string and a list of source objects, each containing source_id, source_text, publisher, and publication_date. The function should validate inputs before calling the model: reject empty claims, require at least two sources, and strip sources that are near-duplicates (cosine similarity > 0.95 on embeddings) to prevent inflated corroboration scores from syndicated content. On the output side, parse the JSON response and validate that corroboration_score is a float between 0.0 and 1.0, independent_sources_count is an integer ≤ total input sources, and echo_chamber_detected is a boolean. If parsing fails, retry once with a repair prompt that includes the raw output and the expected schema. Log all failures for later prompt debugging.

Model choice matters here. Use a model with strong reasoning and structured output capabilities—GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro are appropriate. Avoid smaller or older models that may conflate source count with source independence. Set temperature=0 for deterministic scoring. If your pipeline processes high-stakes claims (medical, legal, financial), route claims with corroboration_score < 0.5 or echo_chamber_detected == true to a human review queue before any downstream answer generation. Store the full prompt, response, and parsed score in your observability system so you can trace corroboration decisions back to specific sources and model calls during audits.

For batch or high-throughput pipelines, consider batching multiple claims into a single prompt call with a JSON array output to reduce API overhead. However, keep batches small (≤10 claims) because larger batches degrade scoring accuracy as the model loses focus on individual source relationships. If you use this prompt inside an agent loop where claims are generated dynamically, cache corroboration scores per claim-source-set combination to avoid redundant API calls. Finally, run periodic evaluations: sample 100 scored claims per week, have domain experts rate the corroboration scores for accuracy, and recalibrate your human-review thresholds if the model drifts or if new source patterns emerge in your retrieval corpus.