Source Attribution for Agent-Generated Answers Prompt

This prompt is designed for agent systems that synthesize final answers from multiple tool calls and retrieval steps. Its primary job is to produce per-statement source attribution, tracking exactly which tool, document, or API response each factual claim derives from. The ideal user is an AI engineer or product developer building a compound agent where a single answer may be assembled from a web search, a database lookup, and a document retrieval call. Without this prompt, the provenance of each claim is lost in the agent's internal reasoning, making it impossible to verify outputs or debug hallucinations after the fact.

Use this prompt when your agent trajectory spans three or more distinct tool calls and the final answer combines evidence from multiple origins. It is essential when downstream users need to click a citation and see the exact source, or when an audit trail must prove that a claim came from a specific retrieval step and not from the model's parametric knowledge. The prompt requires the full agent trajectory as input, including tool names, query parameters, and raw responses. Do not use this prompt for single-step RAG where a standard inline citation prompt suffices, or for conversational agents that do not perform tool-use. It is also inappropriate when latency constraints prevent passing the full trajectory context, as attribution accuracy degrades without complete tool-call history.

Before implementing this prompt, ensure your agent harness captures and passes the complete [AGENT_TRAJECTORY] including tool names, input arguments, output payloads, and call order. The prompt works best with structured output schemas that enforce a claim-to-source mapping per statement. Plan for validation: every claim in the output must reference at least one source present in the trajectory, and every cited source must actually contain the claimed information. For high-stakes domains like healthcare, legal, or finance, route outputs with missing or low-confidence attributions to human review. Start by running this prompt against a golden dataset of known agent trajectories where you can verify that attributions are neither hallucinated nor omitted.

This prompt template is designed for agent systems that synthesize final answers from multiple tool calls and retrieval steps. Its core job is to produce an answer where every factual statement is explicitly linked to its origin—a specific tool output, document chunk, or API response—preserving the attribution chain across the agent's entire trajectory. Use this when you need audit-ready traceability, not just a plausible-sounding answer. Do not use this for simple single-hop RAG where a basic inline citation prompt would suffice; this template adds overhead for multi-step provenance tracking that simpler workflows don't need.

textCopy
You are an attribution specialist for an AI agent. Your task is to generate a final answer based on the provided agent trajectory, which includes a sequence of tool calls and their outputs. You must produce an answer where every factual claim is explicitly linked to its source.

## AGENT TRAJECTORY
[AGENT_TRAJECTORY]

## USER QUERY
[USER_QUERY]

## OUTPUT SCHEMA
Produce a JSON object with the following structure:
{
  "answer": "A synthesized, coherent answer to the user query.",
  "statements": [
    {
      "statement_id": "s1",
      "text": "A single, atomic factual claim from the answer.",
      "source_tool": "The name of the tool call that produced the evidence (e.g., 'web_search', 'document_retrieval', 'calculator').",
      "source_reference": "A precise identifier for the evidence within the tool output (e.g., a URL, document ID, chunk index, or line number).",
      "source_excerpt": "The exact text from the tool output that supports this claim.",
      "confidence": "high | medium | low",
      "attribution_gap": "If confidence is not 'high', explain what is missing or uncertain."
    }
  ],
  "unattributed_claims": [
    {
      "text": "A claim in the answer that could not be traced to any tool output.",
      "reason": "Why no source was found (e.g., 'inferred from multiple sources', 'common knowledge', 'no supporting evidence in trajectory')."
    }
  ]
}

## CONSTRAINTS
[CONSTRAINTS]

## EXAMPLES
[EXAMPLES]

To adapt this template, replace the square-bracket placeholders with your specific context. [AGENT_TRAJECTORY] should be a structured log of every tool call and its raw output, preserving the order of execution. [CONSTRAINTS] is where you enforce domain-specific rules, such as 'Never attribute a claim to a source that only partially supports it' or 'Flag any claim derived from a source older than [DATE] as low confidence.' [EXAMPLES] should include at least one multi-step trajectory example showing how a claim that depends on two tool outputs (e.g., a search result and a calculator confirmation) is attributed to both. After copying this template, immediately test it with a trajectory where a tool call fails or returns empty results to ensure the unattributed_claims array is populated correctly rather than silently omitted.

The Source Attribution for Agent-Generated Answers prompt is designed to operate as a post-hoc verification step within an agent loop, not as a standalone generator. After the agent synthesizes a final answer from multiple tool calls and retrievals, this prompt processes the combined trajectory—including the final answer text, the ordered list of tool calls, and the raw content returned by each tool—to produce a statement-level attribution map. The implementation harness must therefore capture the agent's execution trace before invoking this prompt. Store each tool call as a record with a unique tool_call_id, the tool name, input parameters, and the full response payload. The agent's final answer should be captured as a separate string. These two artifacts become the primary inputs to the attribution prompt.

Wire the prompt into the agent's post-generation pipeline. After the agent produces a final answer, immediately invoke the attribution prompt with the answer text and the serialized tool-call trace. The prompt returns a structured JSON array where each object maps a claim from the answer to one or more source tool calls. Implement a validation layer that checks every returned claim against the original answer text to ensure no hallucinated claims were introduced by the attribution step itself. For each attribution, verify that the referenced tool_call_id exists in the captured trace and that the cited evidence substring appears in the corresponding tool response. If validation fails, retry the attribution prompt once with the validation errors included as feedback. If the retry also fails, flag the answer for human review and log the failure for prompt debugging.

Model choice matters for this workflow. Use a model with strong instruction-following and structured output capabilities, such as GPT-4o or Claude 3.5 Sonnet, because the prompt requires precise JSON output and faithful extraction of claims from the source text. Avoid smaller or older models that may introduce attribution errors or fail to maintain the required output schema. Set the temperature to 0 or a very low value (0.1) to maximize deterministic behavior. Enable structured output mode if the model API supports it, providing the expected JSON schema directly. For high-throughput production systems, consider batching multiple agent answers into a single attribution call if the context window permits, but ensure each batch item is independently traceable to its source trace. Log every attribution call with the input trace, raw output, validation results, and any retry attempts. This audit trail is essential for debugging attribution failures and for demonstrating provenance to downstream consumers or compliance reviewers.