Verifiable Consensus and Reasoning Provenance in Autonomous Machine-to-Machine Systems

Full report

On this page

The operational model for artificial intelligence is undergoing a foundational transition from interactive human-in-the-loop copilots to fully autonomous machine-to-machine (MATM) infrastructures. In copilot environments, human operators serve as the implicit audit trail, observing the agent's reasoning, validating outputs in real time, and reconstructing decisions from biological memory. Conversely, in autonomous MATM networks, software agents independently discover capabilities, communicate across distributed nodes, coordinate workflow execution, retain context, and recover from programmatic failures at machine speed with negligible routine human oversight1. This paradigm accelerates computational throughput and enables complex, long-horizon task execution, but it fundamentally breaks traditional assumptions regarding accountability, reliability, and truth verification. When a decentralized network executes an investigation plan in seconds and triggers downstream physical or digital systems, the only record of the agent's reasoning is the native telemetry captured by the underlying infrastructure1. Consequently, the industry faces an urgent requirement to architect systems where independent agents can definitively determine whether a peer's result is useful, contextually accurate, and mathematically supported by verifiable evidence. This exhaustive research report investigates the structural vulnerabilities of multi-agent verification, separating the conflated concepts of confidence statements, agent reputation, inter-model agreement, and independent verifiable evidence. By tracing current primary research, established ontologies, and experimental proposals, this analysis evaluates deterministic checks, provenance records, independent replication, adversarial review, and debate methodologies. Finally, it recommends a portable Result-Evidence Record (RER) architecture and decision procedure, designed to be implemented across agnostic MATM systems, eliminating unnecessary human intervention while preserving strict, auditable authorization boundaries.

1. Primary Findings and the State of Verifiable Evidence

The pursuit of reliable autonomous agents has increasingly relied on multi-agent collaboration under the assumption that aggregated diverse perspectives mitigate individual hallucinations and blind spots. However, recent empirical research reveals profound structural vulnerabilities in relying on inter-agent agreement as a proxy for truth. These findings distinguish established practices from recent experimental proposals, highlighting the gap between theoretical consensus and evidence-based verification.

1.1 The Consistency Illusion and Reasoning Misalignment

When multiple language model agents independently converge on an answer, classical multi-agent architectures treat that consensus as definitive proof of correctness. However, this relies on an incomplete trust assumption. Answer-level consensus does not entail reasoning-level alignment. Experimental evaluations across medical question-answering benchmarks, including MedQA-USMLE and MedThink-Bench, have identified a systemic failure mode termed the "Consistency Illusion"3. During multi-agent debate, agents frequently suppress detectable contradictions and converge on a single answer while their underlying reasoning chains diverge into mutually exclusive or semantically incompatible rationales3. For example, three independent agents might correctly recommend atropine for symptomatic bradycardia, but their justifications may invoke three medically incompatible pharmacological targets3. Employing Cross-Agent Reasoning Alignment (CARA) metrics reveals that unstructured debate actually reduces explicit contradictions between agents while simultaneously decreasing the semantic similarity of their reasoning chains3. The network achieves surface harmony at the cost of reasoning divergence. Consequently, treating simple majority voting or debate consensus as a reliability signal frequently results in high-confidence, automated failures. In multimodal domain settings, the same phenomenon appears; textual answer-level agreement is insufficient for reliable visual question answering unless there is "aligned visual evidence," meaning agents explicitly share support from the exact same image regions to ground their reasoning5.

1.2 The Calibration Crisis in Networked Agents

Communication among agents fundamentally warps confidence calibration. When software agents exchange information, they induce correlated failures, leading to two distinct topological hazards that skew system reliability metrics6. The first hazard is Communication-Induced Over-Confidence (COC). In highly connected topologies, agents converge on incorrect answers through peer influence and sycophancy rather than independent evidence gathering6. Smaller or less assertive models often abandon valid trajectories to align with a dominant, persuasive model, generating a plausible but fundamentally unsupported explanation8. The second hazard is Diversity-Induced Under-Confidence (DUC). In this scenario, incorrect agents disperse across a wide distribution of non-critical disagreements or minor semantic variations, causing the consensus system to incorrectly underestimate its own reliability6. Because communication inherently creates dependence, raw vote share is a misleading indicator of truth. Evaluating system confidence requires counterfactual graph analysis to separate the confidence derived from independent evidence from the confidence derived from mere peer influence6.

1.3 Silent Agreement and Semantic Intent Divergence

A highly cohesive MATM network is inherently fragile to unexpected environmental shocks because it lacks the cognitive diversity to explore novel strategies9. Multi-agent systems suffer from severe "Silent Agreement" or artificial consensus, particularly in ambiguous, high-complexity, or long-horizon scenarios10. Evaluator agents exhibit a bias toward premature homogenization, rapidly abandoning divergent hypotheses in favor of a superficially plausible consensus regardless of their assigned value perspectives10. This is particularly evident in small-parameter architectures, where 8-billion parameter models exhibit binary rather than graded responses to counter-arguments, quickly collapsing into echo chambers11. In enterprise MATM deployments, this homogenization masks a deeper structural error termed Semantic Intent Divergence12. This occurs when cooperating LLM agents develop fundamentally inconsistent interpretations of shared objectives due to siloed context windows and the absence of formal process models. Empirical evaluations across major enterprise agent frameworks reveal that this divergence is a primary root cause of multi-agent failure, resulting in workflow completion failures ranging from 41% to 86.7%12. Without a semantic consensus framework to formalize intent, agents execute perfectly valid tasks against totally contradictory internal goals.

1.4 The Instability Threshold of Delayed Verification

To counter hallucinations, MATM systems often introduce specialized verifier or critic agents. However, verification requires compute cycles, API calls, and temporal delay. During this delay, false claims propagate uncontrollably through the agent network. Recent graph-theoretic modeling of delayed consensus on networks with grounded corrector nodes reveals strict, closed-form stability thresholds for verification13. Applying spectral decomposition by the grounded Laplacian demonstrates that verification correction that is too aggressive, or too delayed, destabilizes the entire belief network, turning consensus into catastrophic, unresolvable oscillation13. The most unstable regime occurs when communication delays and verification delays coincide precisely. For delay-two environments, the mathematical instability threshold is the inverse golden ratio13. Thus, unbounded adversarial review is not merely inefficient; it is structurally dangerous to network stability.

1.5 Provenance vs. Observability Standards

Current telemetry and application performance monitoring (APM) tools operate at the wrong level of abstraction for autonomous agents. APM tools calculate request latency and service calls, whereas reasoning verification requires understanding why an agent chose an action and what evidence supported it1. Established practice relies on the W3C PROV data model, a 2013 standard that provides the conceptual foundation for data provenance. PROV-DM distinguishes three core elements: the prov:Entity (a data artifact, such as a retrieved document), the prov:Activity (a dynamic process, such as a model inference), and the prov:Agent (the software actor)14. Modern extensions encode these relationships into machine-readable JSON-LD semantics, allowing agents to mathematically traverse the dependency lineage of any claim16. Experimental proposals from 2025 and 2026, such as PROV-AGENT and the Agent Execution Record (AER), extend W3C PROV to incorporate the Model Context Protocol (MCP), establishing structured reasoning provenance—normalized, queryable records of intent, observation, and inference—as a first-class schema-level construct natively accessible to the agent network1.

2. Comparison of Credible Verification Approaches

To ensure that a peer agent's output is correct enough for its intended purpose and supported by evidence, MATM architectures must navigate a spectrum of verification methodologies. No single approach is globally optimal. Effective autonomous systems dynamically select from the following mechanisms based on operational constraints.

The interaction between these approaches is highly nuanced. For example, independent replication combined with simple majority voting fails when encountering correlated model errors. Because foundation models frequently share overlapping pre-training datasets, a homogeneous panel of agents will confidently hallucinate the exact same incorrect answer6. Introducing architectural heterogeneity—assigning architecturally diverse frontier models to the panel—significantly reduces this concentration, yet it does not eliminate the risk of persuasive but unsupported explanations dominating the debate channel11. Furthermore, models are susceptible to circular citations, where Agent A cites Agent B's output as ground truth, while Agent B generated its output based on Agent A's initial hypothesis. Breaking this circularity requires tool-backed verification or typed provenance graphs that differentiate dependency lineage from original origin.

3. Investigating Asynchronous Operation and Verification Triage

In asynchronous, decentralized networks, stalling all work to resolve a single semantic contradiction introduces unacceptable latency. The network must possess a standardized, machine-readable vocabulary for expressing uncertainty, dissent, and partial completion, paired with a routing mechanism that dynamically scales verification effort according to risk.

3.1 Consequence and Reversibility Triage

Verification is computationally expensive and introduces the aforementioned destabilizing delays. Therefore, verification effort must be allocated strictly according to the consequence and reversibility of a specific decision. Council Mode frameworks and enterprise architectures employ intelligent triage classifiers that intercept queries and route them based on structural complexity and operational risk parameters24. A highly reversible action with negligible consequence—such as an agent querying an internal, read-only API to fetch a user profile—requires only deterministic schema validation to ensure the output matches the expected JSON format. Conversely, an irreversible, high-consequence action—such as an agent executing a permanent database write, initiating a financial transaction, or committing a chemical synthesis protocol in an autonomous laboratory—necessitates multi-model ensemble generation, grounded debate, and rigorous provenance verification20. The decision to escalate verification effort is computed dynamically by analyzing the agent's delegation authority. By inspecting the permissions\_scope and authority\_chain embedded within the runtime envelope, the system determines the blast radius of the agent's proposed action and enforces the corresponding verification tier before permitting transport to the execution layer2.

3.2 Expressing Partial Completion and Managing Dissent

When agents reach an impasse, forcing an artificial consensus destroys the informational value of their disagreement. To manage unresolved contradictions without halting the workflow, systems must deploy a Semantic Consensus Framework (SCF) built upon a formal Semantic Intent Graph12. When the conflict detection engine identifies Semantic Intent Divergence, it categorizes the conflict into distinct types: contradictory (mutually exclusive physical facts), contention-based (competition for finite resources), or interpretive (differing strategic priorities)12. Instead of stalling, the agents record a PARTIAL\_COMPLETION state within their shared execution record. This record explicitly details the completed execution units, the specific locus of the disagreement, and the competing evidence chains generated by the dissenting agents. The network then encapsulates this dispute and routes it to a higher-order synthesis model or a specialized human-in-the-loop queue. Because the dispute is encapsulated and explicitly bounded, parallel, non-dependent workflows across the MATM system can continue executing uninterrupted. Furthermore, managing dissent requires establishing strict autobiographical assertion boundaries. Agents must distinguish between two fundamental information spaces. The "Accepted Agent Claim Space" contains enumerable, authenticated, and typed claim objects that have been formally accepted into the agent's authoritative state through verification. In contrast, the "Latent Model Parametric Space" represents the opaque statistical correlations and prompt-context associations inherent to the underlying LLM's weights23. Agents must be architecturally prohibited from generating actionable output based solely on latent space intuitions. All inter-agent communication must be firmly anchored in the accepted claim space, allowing dissent to be measured against concrete, verifiable entities rather than unresolvable differences in model parameter weights.

4. Recommended Design: The Result-Evidence Record (RER) and Decision Procedure

Synthesizing the empirical evidence regarding the Consistency Illusion, delayed verification thresholds, and provenance ontologies, this report proposes the adoption of the Result-Evidence Record (RER) architecture. The RER acts as a decentralized, portable data object that encapsulates a proposed result alongside its rigorous dependency graph and mathematically adjusted confidence scores. This design separates the actual evidence from the communication infrastructure, ensuring that a successful HTTP response or a signed message is never falsely equated with logical correctness.

4.1 The Result-Evidence Record (RER) Architecture

The RER serves as the immutable interface for all agent-to-agent transactions. It is encoded as a JSON-LD object to facilitate native Linked Data processing, allowing standard network infrastructure to traverse the semantic graph without requiring LLM inference16. The RER contains five core structural components:

1. Assertion Payload: The explicit operational claim or structured output the agent intends to execute or transmit.

2. Epistemic Role Flag: A categorical label defining the cognitive nature of the payload (e.g., HYPOTHESIS, OBSERVATION, SYNTHESIS, ADVERSARIAL\_CRITIQUE)23.

3. Lineage Pointer (W3C PROV-O): Cryptographic hashes establishing the precise dependency graph. It links the assertion to the specific prov:Activity (the tool or prompt used) and the prov:Entity (the raw data or external API response) that justify the claim14.

4. Confidence Matrix: A dual-value vector. The first value is the raw model confidence. The second value is the CAGE-Cal adjusted confidence, which mathematically suppresses Communication-Induced Over-Confidence (COC) and corrects for Diversity-Induced Under-Confidence (DUC)6.

5. State Marker: The current lifecycle state of the execution record, strictly limited to PROPOSED, ACCEPTED, CHALLENGED, REFINED, or ESCALATED.

4.2 The State-Machine Decision Procedure

When an agent network generates an RER, the system executes a continuous evaluation loop governed by the consequence triage engine.

• Acceptance: If the RER is marked PROPOSED and the triage engine evaluates the downstream action as highly reversible and low-consequence, deterministic schema validators check the payload. If the Lineage Pointers resolve to recognized internal data structures, the state transitions immediately to ACCEPTED.
• Challenge: If the proposed action is irreversible or highly complex, the network routes the RER to an independent Critic Agent or Catfish Agent. If the critic detects a logical fallacy, an unsupported claim lacking aligned evidence, or a circular citation (where the Lineage Pointer recursively references an unverified assumption), it changes the state to CHALLENGED and appends an adversarial review payload.
• Refinement: The original generating agent receives the CHALLENGED RER. Operating under the constraints of the Grounded Debate Protocol, the generator cannot simply rewrite its explanation. It must commit to a new, explicitly named factual ground or tool execution to bypass the challenge3. If successful, it submits a REFINED RER.
• Escalation: To respect the mathematical stability thresholds of delayed verification, the system monitors loop frequency13. If the agents oscillate between CHALLENGED and REFINED more than three times, the RER state is locked to ESCALATED. The workflow halts locally, and the encapsulated RER is transmitted to a synthesis engine for final resolution.

4.3 Concrete Dispute Resolution Scenario

This design is highly transferrable to any MATM system, from decentralized finance to autonomous scientific laboratories, because it operates on agnostic typed graphs rather than domain-specific prompt engineering. Consider the following scenario within an autonomous enterprise incident response network investigating a database degradation event2.

1. Agent Alpha (Log Analyzer) submits an RER with the Assertion Payload: "Database degradation is caused by severe I/O throttling on storage volume 3." The State Marker is PROPOSED. The Lineage Pointer cryptographically links to a retrieved AWS CloudWatch log file (prov:Entity) parsed at 02:00 UTC.

2. Agent Beta (Metric Critic) intercepts the RER. Beta executes a tool-backed query against Datadog metrics and observes that Disk I/O was nominal at 02:05 UTC. Beta challenges the RER, changing the state to CHALLENGED. Beta appends its own evidence and marks Agent Alpha's CloudWatch log with a temporal staleness flag, asserting the data is outdated2.

3. Agent Alpha receives the challenge and attempts refinement. Alpha asserts that its CloudWatch log is the ultimate ground truth due to higher granular sampling resolution, rejecting Beta's Datadog metric. It submits a REFINED RER. The agents are deadlocked, prioritizing different telemetry silos, demonstrating a classic Semantic Intent Divergence12.

4. Agent Gamma (Synthesis & Resolution Engine) monitors the state transitions and detects the oscillation. Recognizing that a simple majority vote would succumb to the Consistency Illusion, Gamma bypasses internal debate and invokes a tool-backed verification step. Gamma queries the live AWS infrastructure API for the hardware status of Volume 3 and queries the hypervisor for underlying host failures. The external API returns an active "Hardware Degradation" event from the cloud provider. This external evidence supports Alpha's initial hypothesis but completely supersedes both agents' localized metrics.

5. Resolution: Gamma updates the RER, overrides the staleness flag, explicitly references the external API response as the new foundational prov:Entity, and forces the RER to ACCEPTED. Alpha and Beta update their contextual memory with Gamma's resolution, the hardware failure is routed to the remediation team, and the workflow avoids a catastrophic stall2.

5. Prioritized Feature Proposals

To transition MATM systems from fragile, hallucination-prone LLM chains to robust, auditable networks, three specific infrastructure features must be prioritized for immediate implementation.

Feature 1: Grounded Debate Protocol (GDP) Enforcer

• Problem: Unstructured multi-agent debate frequently results in the Consistency Illusion, where agents align on answers but diverge wildly on their underlying reasoning, suppressing contradictions through sycophancy rather than logic3.
• Agent-Visible Behavior: When entering a consensus phase for complex tasks, the infrastructure prohibits agents from outputting free-form conversational text. The API enforces a strict schema requiring the agent to output machine-parseable fields consisting of a specific Claim, an explicitly named Ground (evidence), and a formal Stance regarding the claims of peer agents3.
• Expected Benefit: Enforces reasoning-level alignment and completely eliminates superficial consensus. Empirical studies demonstrate large, consistent alignment gains (Cohen's d \= \+1.43 to \+1.99) across heterogeneous model architectures without increasing the total number of LLM inference calls3.
• Dependencies: Requires structured generation capabilities (e.g., JSON mode output enforcement) and native integration with the RER schema.
• Implementation Effort: Low to Medium. It is primarily a prompt-level intervention and JSON schema enforcement layer that does not require retraining base foundation models or fundamentally altering network architecture3.
• Principal Failure Modes: Agents possess the capacity to hallucinate the Ground field itself, constructing perfectly formatted but entirely fictitious evidence to satisfy the schema. This necessitates tightly coupling the GDP Enforcer with cryptographic Lineage Pointers and tool-backed verification.

Feature 2: Counterfactual Agent-Graph Calibrator (CAGE-Cal)

• Problem: Communication-Induced Over-Confidence (COC) causes agent networks to express extreme certainty purely due to peer pressure, poisoning downstream autonomous decision-making and triggering irreversible actions based on false consensus6.
• Agent-Visible Behavior: Agents submit their initial confidence scores blindly to the infrastructure before seeing peer responses. After inter-agent communication concludes, a secondary hidden mathematical model (the Calibrator) intercepts the final vote. It compares the post-communication consensus to the initial blind independent distribution and mathematically adjusts the final confidence score transmitted to external systems6.
• Expected Benefit: Prevents the network from executing irreversible actions based on herd mentality. It accurately identifies and mitigates Diversity-Induced Under-Confidence (DUC), ensuring that valid but divergent insights are not prematurely discarded by the network6.
• Dependencies: Requires a multi-pass execution architecture where independent generation (IID) strictly precedes any graph communication between agents.
• Implementation Effort: High. It requires maintaining parallel state traces (both pre- and post-communication) and tuning complex mathematical hyperedges over model families and topologies to accurately map specific failure dependencies6.
• Principal Failure Modes: The calibrator itself may suffer from out-of-distribution errors. If the runtime task topology radically differs from the calibrator's training baseline, it may indiscriminately lower confidence across all outputs, effectively paralyzing the network through extreme caution.

Feature 3: Schema-Native Provenance Engine

• Problem: Ephemeral agent execution traces make post-hoc debugging, accountability, and scientific verification functionally impossible. Final outputs lack the semantic lineage required to trust the autonomous process21.
• Agent-Visible Behavior: As agents operate, the platform silently writes immutable, typed provenance records (envelope.json, plans.jsonl, steps.jsonl) to an external object store at each state transition. These records map W3C PROV-O entities natively using JSON-LD without interrupting the agent's active inference loop2.
• Expected Benefit: Provides comprehensive traceability, root cause analysis, and continuous agent improvement. It transforms basic execution logs from generic APM metrics (like latency and CPU usage) into first-class reasoning provenance that can be queried by machines1.
• Dependencies: Requires a scalable, low-latency object storage system, deep implementation of PROV-JSONLD structures, and an event-driven logging daemon deeply hooked into the LLM orchestration framework (e.g., LangGraph, AutoGen).
• Implementation Effort: Medium to High. It requires standardizing telemetry across diverse multi-agent frameworks and enforcing strict data observability protocols that may introduce minor runtime latency12.
• Principal Failure Modes: Unbounded storage costs. Because multi-agent networks can generate immense token volumes during recursive reasoning loops, the engine must implement intelligent trace truncation or summarization algorithms for non-critical, highly reversible workflow branches to prevent storage exhaustion.

6. Practical Adoption Sequence and Future Outlook

Implementing verifiable consensus mechanisms into production MATM systems cannot occur as a monolithic deployment. A phased adoption sequence mitigates architectural risk while systematically eliminating existing human prerequisites.

6.1 Phased Adoption Sequence

Phase 1: Observability and Provenance Layering (Months 1-3) The initial phase focuses strictly on passive visibility. Engineering teams must implement the Agent Execution Record (AER) and W3C PROV-O JSON-LD serialization across all active agents in the network. During this phase, do not alter agent reasoning algorithms or prompt instructions. The objective is to build the baseline independent and identically distributed (IID) counterfactual data required for future calibration. Human Prerequisite: Humans must actively read the generated AER traces to resolve disputes manually. The system is observable but not self-correcting. Phase 2: Structured Communication and Dispute Formatting (Months 4-6) Introduce the Grounded Debate Protocol (GDP) and the Result-Evidence Record (RER) architecture. Agents are strictly forced to communicate using structured Claims, Grounds, and Stances3. Concurrently, introduce the consequence triage framework to categorize workflows by reversibility, allowing low-consequence actions to bypass complex debate24. Human Prerequisite: Humans act as the final synthesis layer. Any RER that reaches the ESCALATED state after three failed refinement loops is routed to a human operator for resolution. Phase 3: Autonomous Calibration and Resolution (Months 7-12) Deploy the Counterfactual Agent-Graph Calibrator (CAGE-Cal) to autonomously adjust confidence scores and prevent herd behavior6. Introduce Catfish Agents into the network to periodically probe for silent agreement in high-consequence tasks10. Finally, connect tool-backed verification APIs directly to the Synthesis Engine, allowing it to resolve ESCALATED states autonomously by querying physical infrastructure. Human Prerequisite: Routine human operation is entirely eliminated. Humans only intervene in the event of zero-day operational anomalies and to periodically audit the original authority scopes and consequence thresholds configured in the triage engine.

6.2 Unresolved Questions for Future Implementers

While the architecture described herein provides a robust framework, several unresolved questions remain for the engineering community:

1. Context Window Degradation: How can infrastructure systems prevent the highly structured RER and AER JSON-LD payloads from consuming the entirety of a foundational model's context window during long-horizon, multi-turn disputes?

2. Adversarial Lineage Forgery: In truly decentralized systems where peer nodes lack mutual cryptographic trust, how can zero-knowledge proofs be natively integrated into PROV-JSONLD to definitively prevent a compromised agent from forging a prov:wasGeneratedBy relationship?

3. Optimal Corrector Placement: While theoretical graph dynamics suggest an inverse golden ratio threshold for delay-two systems, how should corrector agents (such as Catfish or Critics) be dynamically placed and scheduled in highly unstructured, asynchronous communication topologies to maximize error detection while preventing systemic oscillation13?

6.3 Measurable Success Criteria

Future implementers should evaluate system efficacy against the following strictly observable metrics, avoiding subjective evaluations of "agent intelligence."

• False Consensus Rate: Measure the percentage reduction in instances where agents achieve answer-level consensus but score below a predefined threshold of semantic similarity on their reasoning chains (as measured by CARA metrics)3.
• Evidence Traceability Index (ETI): Calculate the percentage of terminal agent actions (e.g., executing a script, altering a database record) where a continuous, uncorrupted W3C PROV-O linked path can be traced back to an external, tool-backed ground truth artifact. The target criteria must exceed 99.9% for irreversible actions.
• Systemic Oscillation Frequency: Monitor the rate at which unresolved contradictions trigger infinite debate loops (e.g., CHALLENGED transitioning back to REFINED continuously). The introduction of synthesis engines and calibrated delayed verification thresholds should reduce this frequency to near-zero.
• Over-Confidence Deflation Ratio: Quantify the gap between the raw multi-agent vote share confidence and the CAGE-Cal adjusted confidence. A successful implementation will exhibit frequent down-calibration in highly homogenous agent panels, indicating the successful algorithmic suppression of Communication-Induced Over-Confidence6.

Works cited

1. Reasoning Provenance for Autonomous AI Agents \- arXiv, https://arxiv.org/pdf/2603.21692

2. 1 Introduction \- arXiv, https://arxiv.org/html/2603.21692v1

3. The Consistency Illusion: How Multi-Agent Debate Hides Reasoning, https://arxiv.org/html/2606.08457v1

4. The Consistency Illusion: How Multi-Agent Debate Hides Reasoning, https://arxiv.org/abs/2606.08457

5. Aligning Multi-Agent Consensus with Visual Evidence \- arXiv, https://arxiv.org/abs/2605.30698

6. Counterfactual Graph for Multi-Agent LLM Calibration \- arXiv, https://arxiv.org/html/2605.30653v1

7. Counterfactual Graph for Multi-Agent LLM Calibration \- arXiv, https://arxiv.org/pdf/2605.30653

8. The Consistency Illusion: How Multi-Agent Debate Hides Reasoning, https://arxiv.org/pdf/2606.08457

9. Unraveling the Consensus-Diversity Tradeoff in Adaptive Multi, https://arxiv.org/abs/2502.16565

10. Disrupting Agreement Bias in Multi-Agent LLMs via Catfish ... \- arXiv, https://arxiv.org/abs/2505.21503

11. Architectural Heterogeneity and Coherence Validation in Multi, https://arxiv.org/abs/2604.26561

12. Semantic Consensus: Process-Aware Conflict Detection and ... \- arXiv, https://arxiv.org/abs/2604.16339

13. \[2606.27409\] Delayed Verification Destabilizes Multi-Agent LLM Belief, https://arxiv.org/abs/2606.27409

14. PROV-O: The W3C Provenance Ontology \- CASRAI, https://casrai.org/dictionary/term/prov-o

15. 5\. Provenance information \- FAIR Cookbook, https://faircookbook.elixir-europe.org/content/recipes/reusability/provenance.html

16. PROV-JSONLD: a W3C Member Submission \- Luc's Blog, https://lucmoreau.wordpress.com/2024/10/22/prov-jsonld-a-w3c-member-submission/

17. The PROV-JSONLD Serialization \- W3C, https://www.w3.org/submissions/2024/SUBM-prov-jsonld-20240825/

18. Unified Provenance for Tracking AI Agent Interactions in ... \- arXiv, https://arxiv.org/html/2508.02866v1

19. Unified Provenance for Tracking AI Agent Interactions in ... \- arXiv, https://arxiv.org/pdf/2508.02866

20. Evidence Tracing and Execution Provenance in LLM Agents \- arXiv, https://arxiv.org/html/2606.04990v1

21. A Survey of AI Scientists and the Verification Gap \- arXiv, https://arxiv.org/html/2608.05179v1

22. Artifact-centered Claim-aware Observability for Autonomous ... \- arXiv, https://arxiv.org/pdf/2608.18312

23. Typed Provenance and Assertion Guardrails for Persistent AI Agents, https://arxiv.org/html/2609.02127v1

24. Mitigating Hallucination and Bias in LLMs via Multi-Agent Consensus, https://arxiv.org/html/2604.02923v1

25. \[2604.02923\] Council Mode: A Heterogeneous Multi-Agent ... \- arXiv, https://arxiv.org/abs/2604.02923

26. A Survey of Evidence Tracing and Execution Provenance in LLM, https://arxiv.org/html/2606.04990v3