> ## Documentation Index
> Fetch the complete documentation index at: https://mwillaimission.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# AgentLedger Architecture: Stack Position and Design

> How AgentLedger's three components fit together — stack position above MCP and A2A, each component's function, and the design principles behind every decision.

AgentLedger sits between the communication protocols that agents already use and the orchestration frameworks that coordinate them. It does not replace MCP, A2A, or agents.txt — it makes them trustworthy by adding a dedicated layer for structured discovery, immutable attestation, and tamper-proof action logging. This page explains how the three components fit together and the design principles that govern every architectural decision.

## Stack position

AgentLedger occupies a distinct layer between low-level communication protocols and high-level orchestration frameworks. Understanding this position clarifies what it does — and what it deliberately does not do.

```text theme={null}
┌─────────────────────────────────────┐
│       ORCHESTRATION FRAMEWORKS      │  ← LangGraph, CrewAI, etc.
├─────────────────────────────────────┤
│           AGENTLEDGER               │  ← Trust + Discovery layer
│  ┌──────────┬──────────┬─────────┐  │
│  │ Manifest │  Trust   │  Audit  │  │
│  │ Registry │  Ledger  │  Chain  │  │
│  └──────────┴──────────┴─────────┘  │
├─────────────────────────────────────┤
│     COMMUNICATION PROTOCOLS         │  ← MCP, A2A, agents.txt
├─────────────────────────────────────┤
│       AGENT-NATIVE SERVICES         │  ← The actual APIs
└─────────────────────────────────────┘
```

AgentLedger does not compete with MCP or A2A. It sits above them and makes them trustworthy.

## Component summary

Each component addresses a distinct gap in the current protocol stack while interoperating with the others.

| Component                                            | Function                                                                                 | Analogous to                                            |
| ---------------------------------------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| [Manifest Registry](/architecture/manifest-registry) | Structured capability ontology and semantic discovery API                                | DNS + App Store + NPM, built agent-first                |
| [Trust Ledger](/architecture/trust-ledger)           | Blockchain-anchored attestation records providing immutable, cross-registry trust scores | Certificate Authority infrastructure, but decentralized |
| [Audit Chain](/architecture/audit-chain)             | Tamper-proof action logs enabling liability attribution                                  | Financial transaction ledger + legal chain of custody   |

<CardGroup cols={3}>
  <Card title="Manifest Registry" icon="magnifying-glass" href="/architecture/manifest-registry">
    Discover and query agent-native services using a structured capability ontology and semantic search API.
  </Card>

  <Card title="Trust Ledger" icon="shield-check" href="/architecture/trust-ledger">
    Verify service trust history through blockchain-anchored attestation records that no single party can alter.
  </Card>

  <Card title="Audit Chain" icon="link" href="/architecture/audit-chain">
    Attribute every consequential agent action to an immutable, PII-stripped record for dispute resolution and compliance.
  </Card>
</CardGroup>

## Design principles

Three principles govern every architectural decision in AgentLedger.

**Security-first.** Every architectural decision begins with the assumption that the system will be attacked, that attackers will be well-resourced, and that the damage from a compromised trust registry is qualitatively different from a compromised application. A corrupted trust layer does not harm one user — it harms every agent that routes through it.

**Ledger is the notary, not the database.** Off-chain infrastructure handles the manifest index, query API, and ranking engine for performance. On-chain infrastructure provides the cryptographic proof layer that makes trust claims independently auditable.

**Open standard, reference implementation.** The capability ontology is published as an open standard. The registry is the reference implementation. The moat is the vocabulary, not the store.

<Info>
  Each principle maps directly to a component: security-first shaped the Trust Ledger's on-chain architecture; the notary model defines the Trust Ledger's off-chain/on-chain split; and the open standard commitment drives the Manifest Registry's capability ontology design.
</Info>