MedBeads: An Agent-Native, Immutable Data Substrate for Trustworthy Medical AI

Abstract: Background: As of 2026, LLMs demonstrate expert-level medical knowledge. However, deploying them as autonomous "Clinical Agents" remains limited. Current Electronic Medical Records (EMRs) and standards like FHIR are designed for human review, creating a "Context Mismatch": AI agents receive fragmented data and must rely on probabilistic inference (e.g., RAG) to reconstruct patient history. This approach causes hallucinations and hinders auditability. Methods: We propose MedBeads, an agent-native data infrastructure where clinical events are immutable "Beads"--nodes in a Merkle Directed Acyclic Graph (DAG)--cryptographically referencing causal predecessors. This "write-once, read-many" architecture makes tampering mathematically detectable. We implemented a prototype with a Go Core Engine, Python middleware for LLM integration, and a React-based visualization interface. Results: We successfully implemented the workflow using synthetic data. The FHIR-to-DAG conversion transformed flat resources into a causally-linked graph. Our Breadth-First Search (BFS) Context Retrieval algorithm traverses relevant subgraphs with O(V+E) complexity, enabling real-time decision support. Tamper-evidence is guaranteed by design: any modification breaks the cryptographic chain. The visualization aids clinician understanding through explicit causal links. Conclusion: MedBeads addresses the "Context Mismatch" by shifting from probabilistic search to deterministic graph traversal, and from mutable records to immutable chains, providing the substrate for "Trustworthy Medical AI." It guarantees the context the AI receives is deterministic and tamper-evident, while the LLM determines interpretation. The structured Bead format serves as a token-efficient "AI-native language." We release MedBeads as open-source software to accelerate agent-native data standards.

• The paper proposes an immutable Merkle DAG architecture for EMRs that ensures any data tampering is instantly detectable through cryptographic integrity.
• The methodology integrates a Go core engine, Python middleware, and React frontend to convert FHIR data into a causally ordered 'Beads' graph.
• Key results demonstrate efficient O(V+E) retrieval for real-time clinical decision support and improved trust in AI medical reasoning.

Summary of "MedBeads: An Agent-Native, Immutable Data Substrate for Trustworthy Medical AI"

Introduction

The paper "MedBeads: An Agent-Native, Immutable Data Substrate for Trustworthy Medical AI" (2602.01086) introduces a novel approach to address the limitations faced by LLM-powered Clinical Agents in existing electronic medical record (EMR) infrastructures. As LLMs reach expert-level competency in medical knowledge assessments, their deployment in real-world settings remains constrained by the context-poor and mutable data structures within current EMRs and frameworks like FHIR. MedBeads proposes a fundamentally different architecture—a Merkle Directed Acyclic Graph (DAG)—that embeds temporal and causal structure directly into the clinical data, facilitating deterministic retrieval and cryptographic integrity.

Methods

MedBeads establishes an immutable data infrastructure, transforming medical records into "Beads"—nodes within a Merkle DAG—that cryptographically reference their causal predecessors. This "write-once, read-many" paradigm ensures data tampering becomes instantly detectable and enables deterministic data retrieval. The MedBeads system is implemented across three layers: a Go-based Core Engine for CAS storage and graph traversal, a Python Middleware for LLM integration and FHIR conversion, and a React Frontend for clinical visualization.

Figure 1: The Context Mismatch visualized. (Left) FHIR's resource-based model with relational references requires complex querying and provides no inherent causality. (Right) MedBeads' Merkle DAG model embeds temporal and causal context directly into the data structure, creating an immutable, AI-traversable history.

Results

The implementation was successfully demonstrated with synthetic patient data using a complete workflow from FHIR data to DAG transformation. The system's architecture allows for efficient context retrieval with $O(V + E)$ complexity, enabling real-time clinical decision support. Tamper-evidence is guaranteed by the mathematical structure of the DAG, where any modification breaks the cryptographic chain of dependencies. The web-based frontend visually demonstrates data causality, providing clinicians with intuitive access to the DAG structure and bridging the trust gap in AI reasoning.

Figure 2: MedBeads System Architecture. The system consists of three layers: The React Frontend (visualizer), the Python Intelligence Layer (handling FHIR conversion and LLM reasoning), and the Go Core Engine (managing CAS storage and graph traversal).

Discussion

The MedBeads architecture represents a paradigm shift from probabilistic data retrieval to deterministic graph traversal, transforming medical records into "trusted memory" for AI agents. This separation of data and reasoning allows healthcare institutions to decouple data infrastructure from AI models, improving regulatory clarity and reproducibility of AI reasoning.

MedBeads optimizes EMRs for AI consumption by structuring data as a compressed semantic language, enhancing token efficiency compared to verbose natural language records. This contributes to reducing hallucination risk in AI-generated outputs by ensuring the context provided is precise, complete, and causally ordered.

Figure 3: Dual Timeline Views in MedBeads. (A) List View: A chronological display of clinical events with color-coded icons representing different Bead categories (encounters, observations, conditions, medications, and procedures), enabling rapid scanning of patient history. (B) Graph View: A DAG visualization where each Bead is rendered as a node with edges explicitly showing parent-child relationships, revealing the causal structure underlying clinical events.

Conclusion

MedBeads offers a robust solution to the context mismatch in medical AI by implementing an immutable, graph-based data structure that enhances data integrity, causal understanding, and auditability. The open-source release encourages the establishment of agent-native standards in healthcare data, aiming for a future where AI agents consume complete and trustworthy context, advancing the deployment of autonomous medical AI. The practical implications are profound, promising improved patient safety, data security, and clinician trust in AI systems.

Figure 4: MedBeads User Interface. The DAG visualization (left) allows clinicians to trace the causal chain of medical events, offering a stark contrast to traditional list-based EMR views. Each node represents an immutable "Bead" of clinical data, linked by cryptographic hashes.