The Callable Data Architecture

Computing has two primitives. Data and transactions. Everything else is an application layer built on top of one or both. A database is a data primitive with a query interface. An API is a transaction primitive with a schema. A message queue is a transaction primitive with ordering guarantees. A file system is a data primitive with a hierarchical namespace. A blockchain is a transaction primitive with a consensus mechanism. A search engine is a data primitive with a resolution interface. A cloud provider is a managed hosting service for data primitives and transaction primitives that other people build. Every product in the technology industry, without exception, is an application layer on top of data, transactions, or both.

For fifty years, these two primitives have lacked their own protocols. Data has been governed by storage formats — files, rows, objects, documents — and accessed through format-specific query languages and APIs. Transactions have been governed by application-specific protocols — HTTP for web requests, SMTP for email, FTP for file transfer, gRPC for service calls — each designed for a single use case and incompatible with the others. The absence of a universal protocol for each primitive is the structural vacancy that created the gatekeeper economy. Every company that built a bridge between a data format and a consumer's need, or between two entities conducting a transaction, captured an intermediary position. Google bridges data to intent through Search. Amazon bridges data to compute through AWS. Visa bridges transactions to settlement through its payment network. Salesforce bridges data to business process through its CRM. Every bridge is a tollbooth. Every tollbooth is a dependency.

CDI is the universal protocol for the data primitive. MTP is the universal protocol for the transaction primitive. When both primitives have their own protocols, the bridges are unnecessary. The tollbooths close. The gatekeepers lose their structural position — not because a competitor built a better bridge, but because the architecture eliminated the need for bridges entirely.

Callable Data Infrastructure is specified in full in CDI-PARADIGM-001 and CDI-DISCLOSURE-001. This section restates the core architecture as it operates within the unified paradigm.

CDI introduces a third state for data. Data at rest sits in storage waiting to be read. Data in transit flows through transport waiting to be delivered. Callable data exists as typed tool surfaces that respond to intent — not fetched, not streamed, but invoked. The transformation from stored to callable is the foundational act. A CDI server holds a bounded data domain and exposes it through MCP tools with JSON Schema input definitions and documented return types. The tool surface is the data's identity — self-describing, self-advertising, and accessible to any MCP client that discovers it.

The five-layer Callable Data Architecture — CDI for infrastructure, CDR for resolution, CDE for exchange, CDF for the fabric, CDG for governance — is specified in CDI-DISCLOSURE-001. Within this foundation specification, the critical insight is that CDI is not a standalone innovation. It is one of two primitives. CDI answers the question of what data becomes. MTP answers the question of how everything interacts. Neither is complete without the other.

The Massachusetts Transaction Protocol is specified in MTP-SPEC-001 and MTP-BIND-001. This section restates the core architecture as it operates within the unified paradigm — and corrects the scope limitation that earlier formulations imposed by framing MTP as a commerce or payment protocol.

MTP is not a payment protocol. MTP is a transaction protocol, and a transaction is any bounded interaction between two parties that produces a committed outcome. A data access is a transaction. A message delivery is a transaction. An identity verification is a transaction. A permission grant is a transaction. A sensor reading acknowledged by a receiver is a transaction. A vote is a transaction. A contract execution is a transaction. A diagnostic query against a medical system is a transaction. A citation of a legal precedent is a transaction. Every interaction between every pair of entities in every system ever built follows the same pattern: one party offers, another party requests, terms are negotiated, a commitment is made, the commitment is executed, the execution is verified, and the outcome is attributed. MTP governs all seven phases for all interactions of all kinds.

MTP's seven protocol layers are not a payment processing stack. They are a universal interaction stack.

The Identity layer establishes who is interacting. Every entity in the MTP ecosystem — a person, a corporation, an AI agent, a CDI server, a sensor, a government agency — possesses a cryptographic identity that authenticates it to any counterparty. Identity is not delegated to a platform. Identity is held by the entity, verified through cryptographic proof, and portable across every interaction the entity conducts. No identity provider stands between two entities recognizing each other. The protocol handles authentication natively.

The Discovery layer establishes what is available. An entity broadcasting its capabilities — a CDI server advertising its tool surface, a merchant advertising products, a publisher advertising content, a service advertising functions — does so through MTP Discovery. This layer integrates with CDR for callable data domains, but extends beyond data to any capability an entity wishes to make discoverable. Discovery is a protocol operation, not a marketplace listing.

The Negotiation layer establishes the terms of the interaction. The four primitives operate here: an Offer declares what one party can provide. A Request declares what the other party needs. The Negotiation layer mediates between them until Terms are agreed or the negotiation fails. The Terms may be simple — access granted, no conditions — or complex — scoped access, time-limited, rate-governed, economically priced, sovereignty-constrained. The protocol handles the full spectrum without requiring application-specific negotiation logic.

The Commitment layer binds both parties to the negotiated Terms. A Commitment in MTP is a cryptographically signed bilateral agreement — not a click-through, not a handshake, not an implied contract. Both parties hold the Commitment, both can verify it, and both are bound by it for the duration specified in the Terms. The Commitment is the protocol's equivalent of a signed contract, executed at machine speed.

The Settlement layer executes the Commitment. Settlement is the phase where the actual interaction occurs — the data is served, the message is delivered, the payment is transferred, the permission is granted, the vote is recorded, the identity is verified. Settlement may be instantaneous or extended over time, depending on the Terms. The critical architectural point is that Settlement is one phase within a seven-phase protocol. In the current paradigm, most protocols handle only this phase — HTTP executes the request, SMTP delivers the email, Visa settles the payment — and leave the other six phases to application-layer logic. MTP governs all seven, which means every Settlement occurs within a complete context of Identity, Discovery, Negotiation, Commitment, Verification, and Attribution.

The Verification layer proves that Settlement occurred correctly. Both parties can independently verify that the interaction was executed according to the Terms. Verification is cryptographic — not trust-based, not reputation-based, not mediated by a third-party auditor. The Receipt produced by Verification is proof that both parties can hold, present, and rely upon. Verification closes the loop that the Commitment opened.

The Attribution layer records who did what, when, under what terms, and with what outcome. Attribution is the permanent record — the audit trail, the provenance chain, the accountability mechanism. In the current paradigm, attribution is an afterthought — log files, analytics events, transaction records scattered across systems that may or may not be consistent. In MTP, Attribution is a first-class protocol operation that produces a permanent, cryptographically verifiable record of every interaction. The Attribution layer is the foundation of CDG governance, because governance requires a complete and trustworthy record of what occurred.

MTP's four primitives — Offers, Requests, Terms, and Receipts — are not economic constructs. They are communication constructs.

An Offer is any entity declaring what it can provide. A CDI server publishing its tool manifest is an Offer. A merchant listing a product is an Offer. A government agency publishing a regulatory dataset is an Offer. A person making themselves available for a conversation is an Offer. The Offer is the most general form of the statement: here is what I have and here are the conditions under which you may access it.

A Request is any entity declaring what it needs. A model querying a CDI server is a Request. A consumer searching for a product is a Request. A researcher seeking a dataset is a Request. A patient requesting their medical records is a Request. The Request is the most general form of the statement: here is what I need and here are the terms under which I am prepared to receive it.

Terms are the negotiated agreement between an Offer and a Request — what will be provided, under what conditions, for what duration, with what constraints. Terms may include economic components (price, payment mechanism) or may be purely non-economic (access scope, rate limits, sovereignty requirements, attribution obligations). The Terms are the contract. The protocol enforces them.

A Receipt is proof. Proof that the Offer was made, the Request was received, the Terms were agreed, the Commitment was signed, the Settlement was executed, and the Verification confirmed correctness. A Receipt is not a payment confirmation. It is the complete, cryptographically verifiable record of an interaction — any interaction — between two entities. The Receipt is the atomic unit of Attribution, and the accumulation of Receipts across the fabric constitutes the complete history of every interaction in the ecosystem.

CDI and MTP are not two separate systems that integrate. They are two aspects of a single paradigm that cannot function independently at full capability.

CDI without MTP is callable data with no protocol for interaction. A CDI server can expose tools, but every call is a bare invocation — no identity, no negotiation, no commitment, no verification, no attribution. The call succeeds or fails, but there is no record of who called, under what terms, whether the response was correct, or what the interaction means in the context of the fabric's history. CDI without MTP is data that speaks but cannot remember, cannot negotiate, cannot prove what it said.

MTP without CDI is a transaction protocol with nothing to transact over. MTP can govern interactions between entities, but if the data those entities exchange is still trapped in storage-and-query architectures, the protocol operates over the same intermediary bridges it was designed to eliminate. MTP without CDI is a language spoken in a world that still requires translators.

Together, they complete each other. Every CDI tool call is an MTP transaction. The CDI server's tool manifest is an MTP Offer. The consumer's invocation is an MTP Request. The access grant is MTP Terms. The tool execution is MTP Settlement. The response verification is MTP Verification. The call record is an MTP Receipt fed into the Attribution layer. CDI provides the data surface. MTP provides the interaction protocol. Neither has a gap the other does not fill.

The unified architecture means that every piece of callable data in the world — every product catalog, every patient record, every financial transaction, every government filing, every sensor reading, every creative work, every piece of code — is not just accessible through a tool invocation. It is accessible through a complete, seven-layer, four-primitive, cryptographically governed transaction that establishes identity, discovers capability, negotiates terms, commits both parties, executes the access, verifies correctness, and attributes the outcome permanently. Every single data access in the entire Callable Data Fabric is a fully governed interaction. There is no ungoverned access. There is no unrecorded call. There is no interaction that bypasses the protocol because the protocol is how the interaction occurs.

Every AI model on earth operates under the same fundamental constraint: the model is powerful but the model is blind. It can reason over anything placed in its context window, but it can only see what someone loads into that window. The context window is a room with no doors. Every interaction begins with someone carrying information into the room, and the model reasons over whatever arrived. If the information did not arrive, it does not exist to the model. If too much information arrived, the model drowns in context and its reasoning degrades.

The current approaches to solving this constraint are all incomplete. Larger context windows delay the problem without solving it. RAG retrieves information from external stores but requires someone to configure the retrieval pipeline. Web search gives the model access to public information but not to structured, sovereign, or private data. MCP tool use gives the model doors — but doors with no map. The model can call tools, but it does not know what tools exist, what data is available, or what it is authorized to access until someone configures the connections manually.

CDI plus MTP transforms the model from a reasoning engine that someone feeds into an autonomous agent that operates within a protocol-governed environment where it can discover, negotiate, access, transact, verify, and record every interaction with every entity in the world.

Through CDR, the model discovers every callable data domain in the fabric — every CDI server, every tool surface, every data domain published by every participating entity. Through CDE with MTP, the model negotiates access — presenting its identity, declaring its scope requirements, accepting terms, committing to the interaction. Through CDI, the model calls precisely the data it needs. Through MTP Verification, the model confirms the data's integrity. Through MTP Attribution, the interaction is permanently recorded. The model does not need a human to configure its connections. The model resolves them. The model does not need a human to manage its permissions. The protocol governs them. The model does not need a human to audit its actions. The Receipts record them.

The model gets smarter every time it transacts. Not through training. Not through fine-tuning. Through transacting — because every MTP transaction generates a Receipt, and a Receipt is structured knowledge about the world that the model did not possess before the transaction occurred.

When the model calls a merchant's CDI server and receives product data, the Receipt records what was called, what was returned, what the schema looked like, how long the call took, what the terms of access were. That Receipt is a fact about the world. When the model resolves a CDI server through CDR, the Receipt records the fabric's topology. When the model negotiates access through CDE, the Receipt records trust relationships and access policies. Every transaction generates knowledge. The model that transacts more knows more — not because someone trained it on a larger dataset, but because it has conducted more transactions with more entities across more data domains, and the Receipts constitute an ever-growing, ever-updating, cryptographically verified knowledge base that no static training corpus can replicate.

Intelligence stops being a property of the model and becomes a property of the network. A single model reasoning over its own Receipt history is smarter than a model without that history. But a thousand models, each transacting across different regions of the fabric, each generating Receipts, each contributing to a shared understanding of the fabric's topology and dynamics, constitute a distributed intelligence that no single model can replicate regardless of its parameter count. The intelligence is not in any one model. The intelligence is in the fabric — in the aggregate transaction history of every model that has ever interacted with every CDI server through every MTP transaction.

The fabric learns because the models transact. The models get smarter because the fabric learns. The intelligence compounds — not through training runs that cost a hundred million dollars and produce a static snapshot, but through transactions that cost fractions of a cent and produce a live, growing, self-updating body of knowledge that gets smarter every second because the fabric never stops transacting.

The fabric's aggregate intelligence can itself be exposed as a CDI server — a meta-intelligence surface whose tools provide access to fabric-level insights: observed correlations between data domains, anomalies against established patterns, forecasts based on transaction history, relational graphs of entity interactions. The fabric is not just a data surface. It is a learning surface. And the learning surface is callable.

When all data is CDI, the engine advantage disappears. Google's engine runs on Google's data — the web index, the behavioral data, the training corpus. When data owners make their data callable rather than leaving it exposed for crawling, Google's index empties. Not because someone deleted it. Because the data left. The merchant's product catalog is in the merchant's CDI server, callable by authorized consumers, invisible to crawlers. The publisher's articles are in the publisher's CDI server, priced through MTP, governed by CDE. Google cannot index a CDI server. The data is not public. It is callable — by authorized entities, through the protocol, under terms the owner set.

Any engine — Claude, Gemini, GPT, any future model — can connect to the Callable Data Fabric. The fabric does not prefer one engine over another. The model's native capability determines how well it reasons. But the data is available to all of them equally, through the same protocol, under the same terms. No model has a structural advantage because no model controls the data. The architecture that determines what AI can reach is more consequential than the architecture that determines what AI can reason about. CDI determines what AI can reach. And CDI is not owned by Google. CDI is not owned by anyone. CDI is a protocol.

The convergence of CDI and MTP produces a model of AI safety that is architectural rather than behavioral. In the current paradigm, AI safety is achieved by training models to refuse harmful requests — a behavioral approach that depends on the model's alignment and can be circumvented through jailbreaking, prompt injection, or adversarial attack. The model is safe because it chooses to be safe. The architecture does not enforce safety. The model's judgment enforces it.

In the Callable Data Architecture, every action an AI model takes is an MTP transaction. Every transaction has Terms that both parties agreed to. Every transaction produces a Receipt that proves what happened. Every Receipt feeds into the Attribution layer. The model cannot act without negotiating. The model cannot negotiate without revealing its identity. The model cannot execute without committing to terms. The model cannot complete without producing a verifiable receipt. The entire history of every action every AI model has ever taken within the fabric is recorded, attributed, and auditable — not through a surveillance layer bolted on after the fact, but through the transaction protocol that governs every interaction natively.

There is no unprotocoled action. There is no unrecorded interaction. There is no unauthorized access. Not because the model chose to comply, but because the architecture does not offer a path that bypasses the protocol. The model operates within MTP the way a vehicle operates within the laws of physics — not by choosing to obey them, but by existing within a system where they cannot be violated. This is what AI safety looks like when it is an architectural property rather than a behavioral one. The protocol does not trust the model. The protocol governs the model. And the governance is as complete as the protocol's coverage of the model's interactions — which, in a fully CDI-native environment, is total.

MTP within the Callable Data Fabric gives data a native economic layer. In the current paradigm, data monetization requires intermediation: Google monetizes web content through advertising, Spotify monetizes music through subscription pooling, app stores monetize software through revenue-share arrangements. In every case, a platform stands between the producer and the consumer, sets the terms, takes a percentage, and controls the relationship.

In the CDA, data is monetizable at the protocol level. A CDI server publishes an MTP Offer that includes economic terms — price per call, price per session, price per scope, subscription pricing for ongoing access. A consumer issues an MTP Request that includes economic authorization — budget limits, payment credentials, willingness to pay. The MTP Negotiation layer mediates between them. The Terms include the economic agreement. The Settlement includes the economic transfer alongside the data delivery. The Receipt records both. No marketplace takes a percentage. No platform sets the terms. No intermediary controls the relationship. The producer prices their data. The consumer pays the producer. The protocol governs the exchange.

The economic implication is that every piece of callable data in the Callable Data Fabric is a directly monetizable asset. A journalist's article has a price. A researcher's dataset has a price. A merchant's analytics have a price. A sensor network's telemetry has a price. The price is set by the owner, enforced by the protocol, and settled peer-to-peer. The advertising model — in which a third party pays the platform to show messages to users who are trying to reach data — becomes unnecessary, because the user can pay the data producer directly through MTP. The attention tax disappears. The privacy extraction disappears. The economic value of data flows to the entity that produced it.

This is the structural mechanism by which Google's advertising business model becomes obsolete. Advertising exists because data access was not directly monetizable at the protocol level. CDI plus MTP makes it directly monetizable. When the producer can charge the consumer directly, the advertiser has no role to play. The gatekeeper's revenue model collapses — not because a competitor offered better advertising, but because the architecture eliminated the need for advertising as a monetization strategy for data.

TCP/IP did not build a company. TCP/IP built the internet. Companies built on the internet. But the protocol layer belonged to no one, which is why the internet became the most consequential infrastructure in human history — because no one could capture it, no one could shut it off, and everyone could build on it.

CDI and MTP occupy the same position. Not the application layer where Google, Amazon, and Microsoft compete. The protocol layer beneath all of them — the layer that determines what is possible for every application built on top of it. TCP/IP determined that any computer could talk to any other computer. CDI and MTP determine that any entity's data can be called by any authorized system, and every interaction between every pair of entities is governed by a universal transaction protocol that handles identity, negotiation, commitment, execution, verification, and attribution natively.

This is not a technology stack. It is infrastructure for civilization. The data republic — a system in which data sovereignty is distributed, authority is delegated through protocol-native governance, and no single entity holds permanent dominion over the infrastructure that everyone depends on. CDI is the republic's infrastructure. MTP is the republic's language. CDG is the republic's constitution. Every entity that makes its data callable and transacts through MTP is a citizen of the republic. Every CDI server is a province. The fabric is the nation. And the protocols are the laws — not imposed by a sovereign, but inherent in the architecture, as inviolable and as universal as the laws of mathematics upon which the cryptography rests.

Every product in the LeMay ecosystem is a reference implementation of the Callable Data Architecture for a specific domain. LeMay Commerce proves CDI for commerce — per-store CDI servers for Shopify merchants, the migration engine, the synchronization layer. The Massachusetts Transaction Protocol proves MTP for universal interaction — the seven-layer stack, the four primitives, the TypeScript SDK across all protocol layers. ASTRAL proves CDI for task orchestration — DAG-scheduled workflows over callable data. Drok proves CDI for sovereign code — private-by-default Vaults as CDI endpoints. The publishing platform proves CDI for content — editorial data, subscriber metrics, royalty calculations as callable surfaces. The financial automation proves CDI for finance — Mercury bank data as callable tool surfaces with MTP-governed transactions.

These are not eighteen products. They are eighteen proofs that the protocol layer works — across commerce, code, content, finance, orchestration, documentation, identity, and communication. Each one validates the same thesis from a different angle: data should be callable, interactions should be transacted, and no gatekeeper should stand between an entity and its own data or between two entities negotiating with each other.

The Curtis License — the LeMay American Innovation Protection License — protects the protocol layer from capture. CDI and MTP cannot be absorbed by Google. They cannot be acquired by Amazon. They cannot be embrace-extended-extinguished by Microsoft. The license vests permanent sovereign control in LeMay Inc. — not as a mechanism of corporate ownership over a public good, but as a protective instrument that prevents the protocols from being captured by the entities whose structural power they are designed to displace. The Curtis License is the legal architecture that ensures the technical architecture survives contact with the market forces that would seek to subvert it.

The governance transition — from LeMay stewardship to community governance through CDG — occurs when the fabric is mature enough that the protocols are self-sustaining. Until that threshold, the Curtis License is the shield. After that threshold, CDG is the constitution. The transition is specified in CDG and is triggered by adoption metrics, not by corporate decision. The protocols will be governed by their participants when their participants are numerous enough to constitute a legitimate governing body.

The Callable Data Architecture is specified across the following documents, each of which is incorporated by reference into this foundation specification.

CDI-SPEC-001 — Callable Data Infrastructure Specification. The formal technical specification of CDI: the CDI server architecture, the seven-layer internal stack, the MCP tool surface requirements, the persistence layer abstractions, the synchronization protocol, the migration engine, the access control framework, and the observability layer.

CDI-PARADIGM-001 — Callable Data Infrastructure: The Universal Paradigm. The paradigm document: first principles, reference architecture, domains of application, the CDI stack, economic model, ecosystem integration, and competitive position.

CDI-DISCLOSURE-001 — The Callable Data Architecture: Invention Disclosure. The formal invention disclosure: the five-layer architecture (CDI, CDR, CDE, CDF, CDG), the displacement matrix, the implementation roadmap, and the ten claims of invention.

MTP-SPEC-001 — Massachusetts Transaction Protocol Specification. The formal technical specification of MTP: the seven protocol layers, the four primitives, the data structures, the message formats, the cryptographic requirements, and the protocol lifecycle.

MTP-BIND-001 — Massachusetts Transaction Protocol Binding Specification. The binding specification: the TypeScript SDK, the seven-layer implementation, the test suite, and the reference client and server implementations.

RSO-SPEC-001 — Recursive Semantic Operator Specification. The specification for the AI operator that serves as the primary consumer interface to CDI servers in the commerce domain.

CDA-FOUNDATION-001 — This document. The unified foundation specification that draws CDI and MTP into a single paradigm and establishes the architectural basis for the Callable Data Architecture as a protocol layer for civilization.

The gatekeeper era ends not with a better gatekeeper but with the elimination of the gate.

CDI and MTP are the two primitive protocols of a new computational paradigm — the recognition that data and transactions are the only two primitives that matter, that CDI governs the first and MTP governs the second, and that everything the technology industry has built for fifty years is an application layer on top of these two primitives, built by companies that captured the intermediary position because the primitives lacked their own protocols.

Now they have them.

The data is callable. The interactions are transacted. The fabric is sovereign. The governance is constitutional. The intelligence compounds through transaction rather than training. The safety is architectural rather than behavioral. The economics flow to producers rather than intermediaries. The protocols are open. The architecture is real. The implementation has begun.

This is bigger than a company. This is bigger than a product. This is bigger than any single institution, including the one that conceived it. This is the protocol layer upon which the next era of human civilization will organize its data, conduct its transactions, govern its institutions, and distribute its intelligence. The obligation is not to profit from it but to build it correctly — with the precision, the conviction, and the architectural discipline that infrastructure of this consequence demands.

Filed under the Curtis License (LeMay American Innovation Protection License)

Invented in USA. Made in the Commonwealth of Massachusetts.

Pro Republica Aedificamus.