Information Provenance & Multi-Source Synthesis

Official Exam Guide Objectives

Task 5.6: Preserve information provenance and handle uncertainty in multi-source synthesis.

Knowledge of

• How source attribution is lost during summarization steps when findings are compressed without preserving claim-source mappings
• The importance of structured claim-source mappings that the synthesis agent must preserve and merge when combining findings
• How to handle conflicting statistics from credible sources: annotating conflicts with source attribution rather than arbitrarily selecting one value
• Temporal data: requiring publication/collection dates in structured outputs to prevent temporal differences from being misinterpreted as contradictions

Skills in

• Requiring subagents to output structured claim-source mappings (source URLs, document names, relevant excerpts) that downstream agents preserve through synthesis
• Structuring reports with explicit sections distinguishing well-established findings from contested ones, preserving original source characterizations and methodological context
• Completing document analysis with conflicting values included and explicitly annotated, letting the coordinator decide how to reconcile before passing to synthesis
• Requiring subagents to include publication or data collection dates in structured outputs to enable correct temporal interpretation
• Rendering different content types appropriately in synthesis outputs—financial data as tables, news as prose, technical findings as structured lists—rather than converting everything to a uniform format

What You Need to Know

Provenance — knowing where a claim came from and how much weight it can bear — is what separates a research system whose output can be trusted from one that produces convincing fiction. What the exam tests is whether attribution survives a multi-agent pipeline, how conflicting sources should be treated, and why dates prevent false contradictions.

Structured Claim-Source Mappings

Provenance travels with the finding or it does not exist. This is not decorative metadata; it is what makes the final report checkable. Every finding carries:

• Claim: exactly what is being asserted
• Source URL: the address it came from
• Document name: what that source is called
• Relevant excerpt: the passage doing the supporting, quoted
• Publication date: when it was published, or when the data was gathered

{
  "claim": "Global renewable energy investment reached $495 billion in 2023",
  "sourceUrl": "https://example.com/iea-report-2024",
  "documentName": "IEA World Energy Investment Report 2024",
  "relevantExcerpt": "Total investment in renewable energy technologies reached approximately $495 billion in calendar year 2023, representing a 17% increase over 2022.",
  "publicationDate": "2024-06-15"
}

The hazard is summarisation, because compressing is what a synthesis agent is for. Combining findings from several subagents, it paraphrases — and paraphrase drops the specifics first. Left without explicit instruction, what emerges is "investment in renewable energy has grown significantly": no figure, no source, no date, and nothing anyone can verify.

Preserving and merging those mappings has to be an explicit requirement on every downstream agent. Three things follow from that:

1. Subagents emit findings already in the claim-source shape, rather than as prose to be parsed later.
2. The synthesis prompt states that mappings survive the merge — it will not happen by default.
3. The finished report carries citations inline, or a reference section, so every claim leads back to a source.

Conflict Handling

Two credible sources reporting different figures for the same measure puts a decision in front of the synthesis agent, and the exam is interested in which one it makes.

Example: Source A reports 12% market growth. Source B reports 8% market growth. Both are credible publications.

Wrong approach: take whichever was published later, split the difference, or defer to the bigger name.

Correct approach: Annotate with both values and full source attribution. Let the consumer decide.

Market growth estimates vary by source:
- **12% growth** — IEA World Energy Report, published June 2024, measuring calendar year 2023
- **8% growth** — Bloomberg NEF Annual Review, published March 2024, measuring July 2022 to June 2023

The two windows do not coincide, and the methodologies differ, either of which would account for the gap.

Both figures survive, and so does what a reader needs to weigh them. Every alternative — taking the newer, taking the average, taking the more prestigious masthead — discards one real measurement and reports the survivor with a certainty the evidence never supported.

Temporal Awareness

Numbers that differ because they were measured at different times are not in conflict, and losing the dates is what makes them look as though they are.

Consider two sources:

• Source A (published 2023): reports 8% growth
• Source B (published 2024): reports 12% growth

Stripped of dates these read as a disagreement to be resolved. With dates they read as growth accelerating from 8% to 12% — the same two numbers, describing a trend rather than an inconsistency.

Every structured output should carry the publication date, or the date the data was collected. Treating that as optional metadata is the mistake. Without it a synthesis agent has no way to distinguish a trend from a data quality problem, and may flag or suppress findings that were consistent all along.

Which means the dates have to be collected by the subagents, carried through the merge, and printed beside the figures they belong to. Dropped at any one of those points, the interpretation fails at the end.

Content-Appropriate Rendering

The exam tests whether you understand that synthesis should not flatten everything into a uniform format:

Financial data → Tables. Figures exist to be compared, and comparison across rows and columns is immediate in a way it never is in a paragraph.

News and current events → Prose. Causes, consequences and sequence are what matters, and sentences carry those relationships where a bullet list breaks them apart.

Technical findings → Structured lists. Architectural patterns, API specifications and configuration options are enumerable, and a list makes their hierarchy visible.

Forcing one format across all of it costs comprehension in whichever direction you err: a financial table as prose hides the comparison, a narrative as bullets loses the causation. The agent should choose the rendering the content calls for.

Attribution Preservation Through Multi-Step Synthesis

In a multi-agent pipeline, attribution must survive every step:

1. Research subagent collects findings with claim-source mappings.
2. Analysis subagent evaluates findings and adds assessment, preserving original mappings.
3. Synthesis subagent combines findings from multiple agents, merging mappings.
4. Report generation produces the final output with inline citations.

Each handoff can drop it, and step 3 is where it usually goes: combining and paraphrasing is precisely the operation that discards specifics, so the synthesis prompt has to state that every claim in its output remains traceable to a source.

Reports should also separate what is well-established from what is contested, keeping each source's own characterisation and its methodological context. A finding three independent sources agree on is not the same as one resting on a single report, and prose that presents both in the same confident register has quietly destroyed that distinction.

Completing Analysis with Conflicts Intact

Where analysis meets contradictory values, it finishes its work and annotates the contradiction rather than settling it. Resolution belongs to the coordinator or to the reader, who have context the analysis agent does not.

{
  "field": "annualRevenue",
  "conflictDetected": true,
  "values": [
    {
      "value": "$4.2M",
      "source": "Annual Report 2023",
      "context": "Audited statements; fiscal year ended December 2023"
    },
    {
      "value": "$3.8M",
      "source": "SEC Filing Q4 2023",
      "context": "Unaudited preliminary figures; calendar year 2023"
    }
  ],
  "possibleExplanation": "One set is audited and the other preliminary, and the two cover a fiscal year and a calendar year respectively"
}

The context on each value is what makes the conflict tractable: audited against preliminary, fiscal year against calendar year. With that recorded, the coordinator can present both, investigate, or send it to an analyst — decisions that are unavailable once one figure has already been silently chosen.

Deep Dive

The CitationAgent pattern — a dedicated post-synthesis attribution step

Anthropic's multi-agent research system has a distinct pipeline stage after synthesis whose only job is provenance: "CitationAgent processes documents to identify specific locations for citations," running after "LeadResearcher synthesizes results and decides whether more research is needed." Splitting citation-matching into its own step, rather than expecting the synthesis agent to get both the content and the sourcing right simultaneously, is a direct answer to this lesson's claim that synthesis (step 3) is the most common point where attribution dies — Anthropic's production architecture routes around that risk by giving attribution its own dedicated agent.

Sourceanthropic.com › multi-agent-research-systemfetched 2026-07-30

Source quality heuristics prevent low-quality sources from dominating synthesis

Provenance is worthless if the underlying sources are unreliable. Anthropic found that "our early agents consistently chose SEO-optimized content farms over authoritative but less highly-ranked sources," and fixed it by "adding source quality heuristics to our prompts." A claim-source mapping that faithfully cites a low-authority source is technically traceable but still misleading — provenance and source-quality filtering are complementary controls, not substitutes for each other.

Sourceanthropic.com › multi-agent-research-systemfetched 2026-07-30

The artifact/filesystem output pattern preserves fidelity through multi-stage pipelines

Anthropic's system lets "subagent outputs... bypass [the] main coordinator for certain types of results, improving fidelity and performance," which "prevents information loss during multi-stage processing and reduces token overhead from copying large outputs." This is the architectural cousin of claim-source mapping preservation: instead of relying on every intermediate agent to faithfully retype a large structured artifact (a table of findings, a long excerpt) as it passes through the pipeline, the artifact is written once and referenced, which removes an entire class of "attribution dropped during a copy" failure.

Sourceanthropic.com › multi-agent-research-systemfetched 2026-07-30

Structured formats separate content from metadata to preserve attribution across agents

The exam guide's Task 1.3 (subagent context passing) names the general skill this lesson's claim-source schema is an instance of: "using structured data formats to separate content from metadata (source URLs, document names, page numbers) when passing context between agents to preserve attribution." Bundling a claim and its source together as unstructured prose invites exactly the kind of loss this lesson describes; keeping them as separate, explicitly labelled fields is what makes the mapping survive a hand-off between agents.

Sourceanthropic-partners.skilljar.com › partner-certificationsfetched 2026-07-30

conflict_detected booleans for values that must not be silently reconciled

Task 4.4 (validation and retry loops) names the schema pattern this lesson's conflict-annotation example implements: "adding conflict_detected booleans for inconsistent source data." Structured-output schemas support this directly — JSON Schema's null basic type and nullable enum members let a field explicitly represent "genuinely absent" as distinct from "in conflict," so a downstream consumer of the schema can tell apart a field with no data, a field with one confident value, and a field with two conflicting values awaiting reconciliation.

Sources: https://anthropic-partners.skilljar.com/page/partner-certifications (the conflict_detected objective) · https://code.claude.com/docs/en/agent-sdk/structured-outputs (supported JSON Schema features, including the null basic type and enum) (fetched 2026-07-30)

Quick Reference

Exam Traps

Practice Scenario

Build Exercise

Build a Provenance-Preserving Synthesis Pipeline

Difficulty: Advanced (3/4)

60 minutes

1. Define a structured claim-source mapping schema with fields: claim, sourceUrl, documentName, relevantExcerpt, publicationDate

Why: Every finding in a multi-agent research system must carry its provenance. Without structured claim-source mappings, attribution dies during summarisation and the final output becomes untraceable plausible-sounding text with no verifiable sources.

You should see: A TypeScript interface or JSON schema with all five required fields: claim (the assertion), sourceUrl (where found), documentName (title), relevantExcerpt (supporting passage), and publicationDate (when published or data collected). Each field should be required, not optional.

2. Implement two research subagents that output findings using the claim-source mapping schema, including publication dates

Why: Subagents must output in the structured format from the start. If subagents return unstructured prose, attribution is already lost before synthesis begins. Requiring structured output at the subagent level is the foundation of end-to-end provenance.

You should see: Two subagent functions that each return an array of ClaimSourceMapping objects with all fields populated, including publication dates. Each subagent should research a different aspect of the same topic.

3. Build a synthesis agent that merges findings from both subagents while explicitly preserving all claim-source mappings through the merge process

Why: Step 3 (synthesis) is the most common failure point for attribution. The synthesis agent naturally compresses and paraphrases, destroying claim-source mappings unless explicitly instructed to preserve them. The exam tests whether you understand that attribution must be explicitly maintained through every synthesis step.

You should see: A synthesis output where every claim is traceable to its source. The synthesis should combine related findings but maintain inline citations or a reference section linking each claim to its original source URL, document name, and publication date.

4. Handle conflicting sources by annotating both values with full attribution and possible explanations, without arbitrarily selecting one value

Why: When two credible sources report different statistics, arbitrarily selecting one destroys information and presents false certainty. The exam tests that the correct approach is to annotate both values with source attribution and let the consumer decide. Different publication dates often explain different numbers as trends, not contradictions.

You should see: A conflict handling function that detects overlapping claims with different values, preserves both with full attribution, and adds a possible explanation noting temporal or methodological differences. The output should never silently pick one value.

5. Implement content-appropriate rendering in the final output: format financial data as tables, news findings as prose, and technical findings as structured lists

Why: The exam tests that synthesis should not flatten everything into a uniform format. Financial data is most readable as tables, news context reads naturally as prose, and technical findings are clearest as structured lists. Forcing all content into one format degrades readability.

You should see: A rendering function that detects the content type of each section and applies the appropriate format. Financial data should appear in tables with columns for year, value, and source. News should be prose paragraphs. Technical findings should be bulleted lists.

Sources

• Claude Certified Architect Foundations Exam Guide — Domain 5, Task Statement 5.6 — Anthropic
• Citations — Anthropic
• How we built our multi-agent research system — Anthropic

Appendix A — Build Exercise Step Hints

Progressive hints revealed by the "Stuck? Get a nudge" control on each step.

Step 1. Define a structured claim-source mapping schema with fields: claim, sourceUrl, documentName, relevantExcerpt, publicationDate

Why: Every finding in a multi-agent research system must carry its provenance. Without structured claim-source mappings, attribution dies during summarisation and the final output becomes untraceable plausible-sounding text with no verifiable sources.

You should see: A TypeScript interface or JSON schema with all five required fields: claim (the assertion), sourceUrl (where found), documentName (title), relevantExcerpt (supporting passage), and publicationDate (when published or data collected). Each field should be required, not optional.

interface ClaimSourceMapping {
  claim: string;          // The specific assertion being made
  sourceUrl: string;      // Where the information was found
  documentName: string;   // Title of the source document
  relevantExcerpt: string; // Specific passage supporting the claim
  publicationDate: string; // ISO 8601 date of publication or data collection
}

// Example
const finding: ClaimSourceMapping = {
  claim: "Global renewable energy investment reached $495 billion in 2023",
  sourceUrl: "https://example.com/iea-report-2024",
  documentName: "IEA World Energy Investment Report 2024",
  relevantExcerpt: "Total investment in renewable energy technologies reached approximately $495 billion in calendar year 2023.",
  publicationDate: "2024-06-15"
};

from typing import TypedDict


class ClaimSourceMapping(TypedDict):
    claim: str             # The specific assertion being made
    source_url: str        # Where the information was found
    document_name: str     # Title of the source document
    relevant_excerpt: str  # Specific passage supporting the claim
    publication_date: str  # ISO 8601 date of publication or data collection


# Example
finding: ClaimSourceMapping = {
    "claim": "Global renewable energy investment reached $495 billion in 2023",
    "source_url": "https://example.com/iea-report-2024",
    "document_name": "IEA World Energy Investment Report 2024",
    "relevant_excerpt": (
        "Total investment in renewable energy technologies reached approximately "
        "$495 billion in calendar year 2023."
    ),
    "publication_date": "2024-06-15",
}

Step 2. Implement two research subagents that output findings using the claim-source mapping schema, including publication dates

Why: Subagents must output in the structured format from the start. If subagents return unstructured prose, attribution is already lost before synthesis begins. Requiring structured output at the subagent level is the foundation of end-to-end provenance.

You should see: Two subagent functions that each return an array of ClaimSourceMapping objects with all fields populated, including publication dates. Each subagent should research a different aspect of the same topic.

async function researchSubagent(topic: string, focus: string) {
  const response = await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 4096,
    tools: [{
      name: "report_findings",
      description: "Report research findings with full provenance",
      input_schema: {
        type: "object" as const,
        properties: {
          findings: {
            type: "array",
            items: {
              type: "object",
              properties: {
                claim: { type: "string" },
                sourceUrl: { type: "string" },
                documentName: { type: "string" },
                relevantExcerpt: { type: "string" },
                publicationDate: { type: "string" }
              },
              // Every field required: an optional sourceUrl is how attribution
              // quietly disappears three stages downstream.
              required: ["claim", "sourceUrl", "documentName", "relevantExcerpt", "publicationDate"]
            }
          }
        }
      }
    }],
    tool_choice: { type: "tool", name: "report_findings" },
    messages: [{ role: "user", content: `Research ${focus} for ${topic}. Report all findings with full source attribution.` }]
  });
  const toolUse = response.content.find(b => b.type === "tool_use");
  return (toolUse.input as { findings: unknown[] }).findings;
}

def research_subagent(topic: str, focus: str) -> list[dict]:
    response = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=4096,
        tools=[
            {
                "name": "report_findings",
                "description": "Report research findings with full provenance",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "findings": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "claim": {"type": "string"},
                                    "sourceUrl": {"type": "string"},
                                    "documentName": {"type": "string"},
                                    "relevantExcerpt": {"type": "string"},
                                    "publicationDate": {"type": "string"},
                                },
                                # Every field required: an optional sourceUrl is
                                # how attribution quietly disappears downstream.
                                "required": [
                                    "claim", "sourceUrl", "documentName",
                                    "relevantExcerpt", "publicationDate",
                                ],
                            },
                        }
                    },
                },
            }
        ],
        tool_choice={"type": "tool", "name": "report_findings"},
        messages=[
            {
                "role": "user",
                "content": (
                    f"Research {focus} for {topic}. "
                    "Report all findings with full source attribution."
                ),
            }
        ],
    )
    tool_use = next(b for b in response.content if b.type == "tool_use")
    return tool_use.input["findings"]

Step 3. Build a synthesis agent that merges findings from both subagents while explicitly preserving all claim-source mappings through the merge process

Why: Step 3 (synthesis) is the most common failure point for attribution. The synthesis agent naturally compresses and paraphrases, destroying claim-source mappings unless explicitly instructed to preserve them. The exam tests whether you understand that attribution must be explicitly maintained through every synthesis step.

You should see: A synthesis output where every claim is traceable to its source. The synthesis should combine related findings but maintain inline citations or a reference section linking each claim to its original source URL, document name, and publication date.

async function synthesiseFindings(allFindings: unknown[]) {
  const response = await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 4096,
    messages: [{
      role: "user",
      content: `Synthesise these research findings into a coherent report.\n\n` +
        `CRITICAL: Every claim in your synthesis MUST include an inline citation [n] ` +
        `linking to the source. Preserve all source URLs, document names, and publication dates.\n\n` +
        `Do NOT paraphrase away attribution. Do NOT say "research shows" without citing which research.\n\n` +
        `Findings:\n${JSON.stringify(allFindings, null, 2)}`
    }]
  });
  return response;
}

// Verify attribution preservation — synthesis is where mappings get dropped.
function verifyProvenance(synthesis: string, originalFindings: unknown[]) {
  const citationCount = (synthesis.match(/\[\d+\]/g) || []).length;
  const claimCount = originalFindings.length;
  return { citationCount, claimCount, preservationRate: citationCount / claimCount };
}

import json
import re


def synthesise_findings(all_findings: list[dict]):
    return client.messages.create(
        model="claude-sonnet-5",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": (
                    "Synthesise these research findings into a coherent report.\n\n"
                    "CRITICAL: Every claim in your synthesis MUST include an inline "
                    "citation [n] linking to the source. Preserve all source URLs, "
                    "document names, and publication dates.\n\n"
                    'Do NOT paraphrase away attribution. Do NOT say "research shows" '
                    "without citing which research.\n\n"
                    f"Findings:\n{json.dumps(all_findings, indent=2)}"
                ),
            }
        ],
    )


# Verify attribution preservation — synthesis is where mappings get dropped.
def verify_provenance(synthesis: str, original_findings: list[dict]) -> dict:
    citation_count = len(re.findall(r"\[\d+\]", synthesis))
    claim_count = len(original_findings)
    return {
        "citation_count": citation_count,
        "claim_count": claim_count,
        "preservation_rate": citation_count / claim_count,
    }

Step 4. Handle conflicting sources by annotating both values with full attribution and possible explanations, without arbitrarily selecting one value

Why: When two credible sources report different statistics, arbitrarily selecting one destroys information and presents false certainty. The exam tests that the correct approach is to annotate both values with source attribution and let the consumer decide. Different publication dates often explain different numbers as trends, not contradictions.

You should see: A conflict handling function that detects overlapping claims with different values, preserves both with full attribution, and adds a possible explanation noting temporal or methodological differences. The output should never silently pick one value.

function handleConflicts(findings) {
  const byTopic = groupByTopic(findings);
  const resolved = [];
  
  for (const [topic, claims] of Object.entries(byTopic)) {
    const uniqueValues = [...new Set(claims.map(c => c.claim))];
    if (uniqueValues.length === 1) {
      resolved.push({ topic, claims, conflictDetected: false });
    } else {
      resolved.push({
        topic,
        claims,
        conflictDetected: true,
        possibleExplanation: `Values differ. ` +
          claims.map(c => `${c.documentName} (${c.publicationDate}): ${c.claim}`).join(" vs ") +
          `. Difference may reflect different reporting periods or methodologies.`
      });
    }
  }
  return resolved;
}

def handle_conflicts(findings: list[dict]) -> list[dict]:
    resolved = []
    for topic, claims in group_by_topic(findings).items():
        unique_values = {c["claim"] for c in claims}
        if len(unique_values) == 1:
            resolved.append({"topic": topic, "claims": claims, "conflict_detected": False})
            continue
        # Both values survive with attribution — never pick one arbitrarily.
        detail = " vs ".join(
            f"{c['document_name']} ({c['publication_date']}): {c['claim']}" for c in claims
        )
        resolved.append(
            {
                "topic": topic,
                "claims": claims,
                "conflict_detected": True,
                "possible_explanation": (
                    f"Values differ. {detail}. Difference may reflect different "
                    "reporting periods or methodologies."
                ),
            }
        )
    return resolved

Step 5. Implement content-appropriate rendering in the final output: format financial data as tables, news findings as prose, and technical findings as structured lists

Why: The exam tests that synthesis should not flatten everything into a uniform format. Financial data is most readable as tables, news context reads naturally as prose, and technical findings are clearest as structured lists. Forcing all content into one format degrades readability.

You should see: A rendering function that detects the content type of each section and applies the appropriate format. Financial data should appear in tables with columns for year, value, and source. News should be prose paragraphs. Technical findings should be bulleted lists.

function renderSection(section) {
  switch (section.contentType) {
    case "financial":
      return `| Year | Value | Source |\n|---|---|---|\n` +
        section.claims.map(c =>
          `| ${c.publicationDate.slice(0, 4)} | ${extractValue(c.claim)} | ${c.documentName} |`
        ).join("\n");
    case "news":
      return section.claims.map(c =>
        `${c.claim} (${c.documentName}, ${c.publicationDate}).`
      ).join(" ");
    case "technical":
      return section.claims.map(c =>
        `- ${c.claim} [Source: ${c.documentName}]`
      ).join("\n");
  }
}

function detectContentType(claims) {
  const hasNumbers = claims.some(c => /\$|\d+%|\d+\.\d+/.test(c.claim));
  const hasTechnical = claims.some(c => /API|architecture|pattern|config/i.test(c.claim));
  if (hasNumbers) return "financial";
  if (hasTechnical) return "technical";
  return "news";
}

def render_section(section: dict) -> str:
    claims = section["claims"]
    content_type = section["content_type"]
    if content_type == "financial":
        rows = "\n".join(
            f"| {c['publication_date'][:4]} | {extract_value(c['claim'])} | {c['document_name']} |"
            for c in claims
        )
        return f"| Year | Value | Source |\n|---|---|---|\n{rows}"
    if content_type == "news":
        return " ".join(
            f"{c['claim']} ({c['document_name']}, {c['publication_date']})." for c in claims
        )
    if content_type == "technical":
        return "\n".join(f"- {c['claim']} [Source: {c['document_name']}]" for c in claims)
    return ""


def detect_content_type(claims: list[dict]) -> str:
    has_numbers = any(re.search(r"\$|\d+%|\d+\.\d+", c["claim"]) for c in claims)
    has_technical = any(
        re.search(r"API|architecture|pattern|config", c["claim"], re.I) for c in claims
    )
    if has_numbers:
        return "financial"
    if has_technical:
        return "technical"
    return "news"

Appendix B — Interactive Study Prompts

Two prompts to paste into Claude. B1 drills the judgement the exam actually measures; B3 reviews the work you produced for the Build Exercise above. The exam simulator between them is the interactive quiz on this page.

B1. Concept Check — Discrimination Drill

B2. Exam Simulator

B3. Build Coach — Code Review

The Build Exercise and its hint ladder are already on this page. This prompt is for the one thing the page cannot do: review the schema, the prompts and the code you actually wrote.