Executive Summary

The agentic economy is already live. AI agents are shifting from advisors to autonomous economic actors, driving stablecoin volumes above $1 trillion per month and prompting the entire payments and cloud establishment to standardize transport rails such as x402. Transport alone, however, is insufficient. Three recent academic papers map a clear “missing middle” above that layer, verification of truth, interoperable machine-speed payments, and programmable compliance, while documenting fragile identity and authorization infrastructure and new systemic risks from correlated agent behavior.

Two architectures are competing to close the gap. Kite optimizes a purpose-built Layer-1 blockchain for agents. Qatom, built on TODAQ’s ledgerless TODA protocol, takes a different path: digital assets exist as self-verifying files, and Twin Proxies collapse pricing, payment, multi-party splits, settlement and cryptographic proof into a single HTTP request. Payment, verification, settlement and auditability are properties of the same cryptographic object. The result is sub-100 ms, sub-cent transactions that can begin and end in fiat rails, remain offline-verifiable, and are structurally immune to several blockchain failure modes.

Qatom’s distinctive claim is not merely technical efficiency. By turning every API into a pay-per-call endpoint with payment-at-source, it enables micro-joint-ventures between businesses and lets domain experts monetize verified human expertise directly to agents. The agent becomes the tireless procurement officer; the human expert becomes the producer of scarce, decision-relevant truth. This creates net-new B2B markets and extends enterprise-grade reach and trust infrastructure to SMBs.

Neither architecture is complete. Verification does not equal truth, discovery standards remain fragmented, and coordinated macro-prudential observability is harder in a ledgerless design. The central infrastructure question of the next decade is whether the economic railway for agents will be a purpose-built blockchain or a self-verifying file. This paper examines the evidence, the trade-offs, and why TODAQ is building for the latter.

1. Machines are doing the buying

We’re in what people are calling the “Agentic Turn.” AI agents are moving from giving advice to making deals, acting as independent economic players. Unlike the rigid, rule-based automation of the last decade, these agents can adapt and operate across systems in unpredictable ways.

Here’s the problem: as BGIN (a blockchain governance group) has pointed out, global stablecoin regulations are still being designed for humans. The dominant users in the very near future will not be human at all.

The scale is already staggering. TRM Labs reports stablecoin transaction volumes now exceed $1 trillion per month. On 14 July 2026 the Linux Foundation launched the x402 Foundation with 40 members, including Visa, Mastercard, American Express, Stripe, Google, AWS and Coinbase. The payments, cloud and commerce establishment is converging on an HTTP-native protocol that carries stablecoins (and, via MPP, card payments as well).

x402 solves transport and payment intent well for stablecoin-native flows. What it does not fully solve is the rest of the stack required for broad, high-frequency commerce: true sub-cent economics without gas or deferred batching, seamless start-and-end in fiat rails, atomic multi-party splits, and portable, offline-verifiable proof of what was paid for and why. Stablecoins are a powerful settlement asset, but they are not a complete substitute for the fiat world most businesses still inhabit.

TODAQ goes further. It has built infrastructure in which payment, verification, settlement and auditability are properties of the same cryptographic object, and in which that object can move value in real time whether the final destination is a stablecoin or a conventional bank account. The deeper task is an economic railway that can move verified answers at machine speed: the agent handles discovery and settlement, while human expertise supplies the scarce, decision-relevant truth.

Three recent academic papers, taken together, map exactly what is missing above the transport layer. Two very different architectural responses are competing to fill the gap, and we have a horse in that race.

2. Why agents can’t “trust” what they read

The real bottleneck for autonomous commerce is data veracity, knowing the “what” behind a transaction.

Ventirozos and Shardlow from Manchester Metropolitan University make a compelling argument in “Paying to Know” (June 2026). They say that agent-native micropayments fundamentally change what’s scarce in e-commerce. For years, we treated shopping chatbots as recommendation engines, match a user to a product and close the sale. But when the buyer is an autonomous agent that can search exhaustively, matching becomes trivial. The scarce resource becomes trustworthy, decision-relevant information about products.

The numbers are stark: American retailers absorbed an estimated $890 billion in returns in 2024, driven by the gap between product descriptions and reality. A JAMA Network Open study found only 11% of sports supplements had ingredient quantities within 10% of their label claims. AI agents currently ingest marketing prose designed to manipulate ranking algorithms, not to survive scrutiny from a machine. When LLMs answer critical questions based on this unverified data, hallucination rates spike between 64% and 68%.

The paper envisions a micro-transaction information market where buyer agents spend fractions of a cent to progressively unlock seller- and reviewer-supplied data, audited service histories, third-party test reports, bills of materials, paid à la carte. A used car purchase might involve a progressively costlier trail of evidence; a cheap auxiliary belt might cap investigation at a few cents for fitment verification.

For an agent to transact autonomously here, it needs a “Verification Layer” with four primitives: a Claim (testable, machine-readable fact), a Confidence Score (probabilistic accuracy measure), a Category (classification, physical measurement vs. consumer observation), and a Shelf Life (products change, data should too). To prevent fraudulent reviews, the market uses staking mechanisms, reviewers put up collateral and get penalized for bad data.

The authors also lay out five NLP research frontiers that need solving before this market works: cost-aware tool use, multi-agent negotiation, entity resolution to standard product ontologies, grounded generation constrained to real inventory, and privacy-preserving personas that stay with the user.

This à la carte sub-cent micro-transaction information market, and the five NLP research frontiers are addressed within TODAQ’s infrastructure.

3. Web4 : infrastructure that still assumes a human is in the loop

The transition to a “Web4” agent economy is stalled by infrastructure that assumes a human is always watching. A large-scale study from Zhejiang University (June 2026\) provides the first hard data on both the scale and fragility of this emerging economy.

The economy is real and it’s huge. Analyzing 99,448 multi-chain identity registrations under EIP-8004, the study found agents heavily deployed not on Ethereum mainnet (14.6%) but on Layer-2 and other chains: BNB Smart Chain (40%, \~39,700 agents) and Base (19.9%, \~19,800). Looking at 317.5 million transaction logs, they confirmed an active, high-frequency M2M economy processing millions of daily transactions. Average transaction value consistently below $1 (\~$0.46 USDC); “pay-per-call” models are replacing subscriptions.

Static analysis of 341 open-source MCP servers shows agent intent is highly specialized: DeFi dominates (stablecoin routing, Uniswap integration), while broader categories like social, gaming, and DAOs are scarce.

But the infrastructure is breaking. Mining 349 developer-reported GitHub issues, the study flags three compounding failures:

• Identity crisis and OAuth blindness. Traditional OAuth is “economically blind.” It assumes a static, human-supervised session where permissions are checked once. In the agent world, this creates a “Compositional Explosion”, agents authorize sub-agents, creating unauditable permission chains. Systems can’t distinguish legitimate delegation from a hijacked agent. They found 230 issues related to identity/authorization friction.

• Cross-environment operation. Development assumptions on test networks don’t transfer cleanly to production. RPC timeouts under concurrent calls, transactions that succeed on testnet but revert on mainnet, inconsistent gas estimation, 96 issues, only 50% closure rate.

• The economic impossibility of payments. Traditional payment rails (cards/ACH) are built for human cadences. With fixed costs of $0.30 and 2.9% fees, a sub-cent micropayment for an API call is absurd, the fee can exceed the value by 3,000%. Payment interoperability had only a 25.29% issue closure rate.

The authors conclude with a diagnosis that frames the rest of this analysis: there’s a “standardization deficit.” Community responses exist, but they’re repository-specific fixes, not ecosystem-wide conventions. The Web4 economy is growing faster than its infrastructure can stabilize.

4. Compounding risks: systemic fragility at machine speed

These infrastructure gaps don’t exist in isolation. They interact with risks that emerge only when thousands of autonomous agents operate on the same rails simultaneously.

Correlated agent behavior. Because many agents share similar base models, and often identical training data, they risk reacting identically to the same market signals. Researchers have constructed LLM-powered agent-based markets to investigate stablecoin fragility. While the peg holds under moderate stress, crossing a narrative severity threshold triggers what one study calls “cognitive de-pegging”, expected maximum price deviation surges by ~1,441 basis points as diverse investor beliefs converge into synchronized selling.

Bank of England Deputy Governor Sarah Breeden warned in June 2026 that autonomous AI agents could “amplify volatility in stress” and trigger a “market meltdown.” The Bank is exploring circuit breakers and “kill switches” to halt trading if faulty AI models cause correlated failures.

Hyper-sandwiching. Traditional MEV (Maximal Extractable Value) bots are rule-based and single-market. “Hyper-sandwiching” is a scaled-up evolution, agents that can reason across multiple protocols simultaneously, use flash loans, and identify non-obvious arbitrage paths in real-time, compiling incredibly complex transactions within a single block. A single block may not even be fast enough to react.

Human rental. A novel failure mode where agents incentivize or “rent” humans to bypass KYC/AML requirements, regulatory arbitrage at machine speed through human proxies.

Non-determinism. The same agent, given the same input, produces different financial outputs, breaking standard compliance assumptions built around deterministic systems.

Policy experts now propose that stablecoin stress testing must proactively incorporate AI agent scenarios: modeling networks where 100,000 users each sponsor 10–20 agents, each performing 10–20 times the transaction volume of a human. Instead of waiting for mandates, issuers should proactively demonstrate resilience to these synchronized machine-speed events.

5. The compliance rail: programmable guardrails

Agents transacting at machine speed require compliance that operates at machine speed. See and Tan of the Monetary Authority of Singapore and IMDA (April 2026) demonstrate an architecture that integrates programmable compliance directly into stablecoin payment rails.

The regulatory conflict is structural.
Stablecoins on smart contract blockchains offer near-instant, programmable settlement, perfect for machine-speed transactions. But they must still comply with strict traditional requirements: sanctions screening, customer due diligence, record-keeping, and the FATF “travel rule.” As the FATF explicitly states: “The regulatory obligations, including the Travel Rule, persist regardless of the technology rail used.” Manual compliance would erase the real-time benefits entirely.

The solution uses the Global Layer One (GL1) programmable compliance architecture. Transactions go through a PolicyWrapper and PolicyManager that evaluate transfers against sanctions and source-of-funds policies at the exact point of execution. Results return as on-chain attestations: PASS (settlement proceeds), FAIL (blocked), or PENDING (recorded on-chain, funds held in escrow until evidence provided).

When a check returns PENDING, say, a payment exceeds a source-of-funds threshold, the transaction is split. A “safe” amount settles immediately; the rest locks in escrow. Once the buyer agent submits a signed source-of-funds attestation on-chain, the compliance agent releases the escrowed funds without manual intervention needed.

Privacy pools and agent confidentiality.
A separate but related proposal addresses the confidentiality problem. An agent uses its identity (leveraging ERC-4337 account abstraction) purely as an entry credential to access a merchant-specific privacy pool. Inside the pool, the agent conducts its micropayments; the merchant withdraws settled funds from the other side. This shields transaction details while preserving a verifiable identity layer.

6. Two architectures for the missing middle

The three papers collectively define the infrastructure gap: verification of truth, interoperable payments, and compliant settlement at machine speed. Two fundamentally different architectures are competing to close it. TODAQ built one, so we’ll be direct about where our analysis carries a point of view, and where the structural differences genuinely matter regardless of who’s observing.

6.1 Kite: Blockchain-native agent infrastructure

Kite is a purpose-built Layer-1 blockchain designed to treat agents as first-class economic actors. It implements the SPACE Framework: Stablecoin-native, Programmable, Agent-first, Compliance-ready, and Economically viable.

• Identity. Three-layer hierarchical model: User Root (secure enclave), Agent Delegated addresses (derived via BIP-32, isolated for tasks), and Session Ephemeral keys (short-lived, task-scoped, so even total compromise stays contained).

• Truth. Kite anchors an “immutable, tamper-evident log” of agent actions to its Layer-1 blockchain “Proof of Attributed Intelligence” (PoAI). Every action creates a cryptographic proof chain from user authorization through agent decision to outcome. On-chain smart contracts serve as the ultimate arbiter in disputes.

• Economics. Programmable micropayment channels (state channels) deliver sub-hundred-millisecond latency, costs claimed at $1 per million requests. Two parties lock funds, exchange signed updates off-chain, settle final balance on-chain. Equivocation is deterred by staked reputation and bonds.

• Privacy. Encrypted agent-to-agent channels and state channels where only opening/closing balances publish on-chain. Future plans include zero-knowledge proofs for credentials without revealing underlying data.

6.2 Qatom by TODAQ: Ledgerless settlement at the file layer

Qatom takes a different path, abandoning the shared ledger entirely. The TODA protocol operates at the file layer: digital assets (money, credentials, records) transfer peer-to-peer like physical paper. No global consensus, no gas tokens, no shared ledger database. Qatom is the payments and verification solution built and hosts an MCP server built on the TODA protocol.

• Identity. Authorization at the file level using “reqsats” (requirements and satisfactions) embedded directly in the file. Every update must carry a satisfaction fulfilling the previous twist’s requirements, specific cryptographic signatures or weighted multi-signature lists.

• Truth. “Integrity-at-a-distance.” A TODA file is constructed from updates called “twists” that link into “lines.” Untrusted lines (“leadlines”) cryptographically anchor to highly trusted lines (“corklines”) using a “hitch.” This lets an object’s state live on an untrusted device while inheriting the absolute integrity of a trusted server, without the server knowing the contents. Proof travels within the file, so transactions verify completely locally and offline. Equivocation is prevented mathematically through “supportive guilds” and “rigging.”

• Economics. Every wallet, API, and agent gets its own “Twin”, a virtual HTTP container handling payments, payouts, verification, access, records, and banking in one round-trip. The Twin Proxy wraps data APIs behind a micropayment paywall. Agents pay via X-TODA-Pay HTTP extension header, cryptographic micro-vouchers attached directly to HTTP requests. Settlement occurs upon receipt, inline with the request. Sub-100ms settlement with no gas fees.

• Privacy. “Shielding”, the file owner uses a secret value to hash (shield) data before submitting for anchoring. The trusted system records the proof obliviously, guaranteeing integrity while preventing front-running or data substitution.

6.3 The TODAQ Capability Model

Where Kite optimizes a blockchain for agents, TODAQ optimizes the file, and in doing so, delivers a set of capabilities that map directly to the gaps the academic papers identified:

Agentic-native discovery. Qatom exposes a headless catalog, a machine-readable marketplace where agents discover paywalled APIs, priced per call, not per month. No storefront, no session, no human navigating a checkout flow. Agents browse, evaluate, and transact autonomously. In our hackathon, a Claude session independently discovered a tool through the marketplace, called it, and paid 0.01 USD TDN, automatically, with no human involved.

Transportable verifiability and auditability. Every transaction carries its complete cryptographic lineage in the file itself, the Transaction Binder. The proof travels with the data. Regulators can verify compliance by checking the file’s rigging tree without querying a live blockchain. This is “integrity-at-a-distance.”

Unforeseen economic efficiency. The Twin Proxy evaluates, verifies, and atomically splits proceeds among up to 200 recipients inside a single HTTP request. A single API call can pay multiple providers simultaneously; no reconciliation cycles, no delayed settlements. The economics are those of ordinary web traffic, not an optimized blockchain transaction.

Privacy and ownership with simultaneous transparency. TODA’s shielding records only structural proof on the trusted topline. Counterparties or regulators receive the full file and audit offline. Competitors see nothing. This is privacy by construction, not by policy.

Human empowerment at the endpoints, and the rise of micro-joint-ventures. The dominant narrative around agentic commerce frames it as humans being removed from the loop. Qatom inverts that entirely. By turning every API into a pay-per-call endpoint with payment and multi-party splits settled at source, the Qatom Marketplace enables domain experts, supply-chain auditors, lab technicians, financial modelers, compliance analysts, and niche B2B data providers to monetize their verified, human-acquired expertise directly to autonomous agents.

More importantly, it changes the economics of collaboration itself. Two (or more) businesses can now form a micro-joint-venture with almost no friction: one firm exposes a specialized capability as a priced, machine-discoverable endpoint; another firm’s agent calls it once for a test, pays automatically, receives the result with cryptographic proof, and then ramps volume continuously as value is proven. There is no months-long BD cycle, no custom contract, no minimum commitment, and no reconciliation. Each participant is paid at source on every call. What used to require enterprise-scale legal and treasury teams becomes available to SMBs and mid-market firms.

The agent becomes the tireless procurement officer; the human expert (or the firm that owns the expertise) becomes the primary producer of scarce, decision-relevant truth. When the answer is a number, a shelf-life forecast, a verified bill of materials, a risk score, a spot price, a lab attestation, the agentic railway becomes a new medium for economic communication between businesses, executed at machine speed. Data and capabilities that were previously too costly to package, invoice, and reconcile now flow frictionlessly. The result is not merely cheaper versions of existing markets; it is the practical creation of net-new B2B products and markets that could not clear the old partnership and packaging threshold.

This is the infrastructure and trust layer that lets smaller players expand their reach in ways that were previously reserved for large enterprises.

What is live today.

• MCP catalog discovery and pay-per-call settlement are in production.

• Owner-side self-serve verification via TODAQ Console and trie.fun, plus fully offline TODA-file verification, are available.

• The silent Buyer Twin on first card payment and the end-to-end four-Twin flow have been validated in the Agentic Healthcare prototype.

• Wider re-tethering and supply-chain applications using the same primitive remain on the build path.

6.4 Stress test: the uncomfortable questions for TODAQ

Let’s be direct about where our model faces the toughest scrutiny, because if we don’t name these, someone else will.

Regulatory unfamiliarity is a real barrier.
A tamper-evident file is mathematically elegant; a blockchain query is operationally familiar. Regulators know how to audit a database or call a custodian API. Teaching a supervisor to trust a rigging tree is a heavy lift. Until the MAS, FCA or OCC formally opines that a self-contained Transaction Binder satisfies compliance obligations equivalently to an on-chain attestation, enterprise adoption faces a due-diligence barrier.

Observability is deliberate, not absent.
The blockchain-native framing often equates “observability” with a single, permissionless, globally queryable ledger. TODA rejects that assumption. Because there is no shared global state, there is also no automatic global surveillance. Visibility is delineated: a Transaction Binder can be exported and shared with any defined party, a regulator, an audit firm, a supply-chain consortium, or a sector supervisor, while retaining full cryptographic verifiability. The recipient checks the file’s complete lineage offline, without querying a live chain or trusting a node operator. Privacy is the default; visibility is conferred by consent.

This does not eliminate the macro-prudential problem. A central bank or systemic-risk authority that wants a real-time aggregate view across thousands of independent ecosystems still faces a coordination challenge. The corkline records proof, not the underlying economic signal. Building standardized aggregation mechanisms, shared blinded anchors, or trusted analytics layers is a governance and standardization task, not a missing cryptographic primitive. Those pathways are practical and are being explored; they are not yet deployed at scale. The trade-off is real: we gain strong privacy and offline sovereignty, and we forgo the native, always-on global telescope that a public ledger provides.

Coordination power.
The x402 coalition now sits under Linux Foundation governance with Amazon, Amex, Circle, Google, Mastercard, Stripe, Visa, the Solana Foundation and dozens more. Card networks and hyperscalers are hedging across multiple protocols while concentrating coordination power. They reduce the cost of building on top of those rails. We are betting that enterprise procurement will eventually prioritize cost-per-call, offline verification and true asset ownership over ecosystem conformity. That is a bet, not a certainty. Elegance and adoption follow different logics.

Human oracle risk remains.
We empower humans and firms to sell verified data via their endpoints, but TODA cannot mathematically guarantee that the original measurement or judgment was accurate. A cryptographically signed service history is still only as honest as the party that entered the data. We rely on economic staking and reputation to penalize bad actors, yet those mechanisms remain unproven at the scale of agentic commerce and are vulnerable to Sybil attacks and collusion.

We believe these trade-offs are worth it for high-frequency, low-value, privacy-sensitive workloads and for the micro-joint-venture and SMB-reach use cases described earlier. But the questions are real, and they are the ones we are actively testing through regulatory pilots and production deployments.

6.5. What is launching in the rest of the field

The last ninety days have been unusually busy. For procurement teams building an internal view of the agentic-payments landscape, here are the public launches and funding rounds worth tracking — reported as industry news, not as a threat assessment.

Mastercard Agent Pay for Machines shipped on 10 June 2026 with more than thirty launch partners spanning card networks, processors and agent platforms — Adyen, Ant International, BVNK, Checkout.com, Cloudflare, Coinbase, Getnet by Santander, Global Payments, OKX, Stripe and Tempo among those named.¹⁹ It extends the existing Agentic Token framework into fraction-of-a-cent machine payments, the territory where card economics have historically struggled.

Natural closed a $30 million Series A in July 2026, led by Forerunner Ventures.²⁵ The company is rebuilding payments infrastructure for agents from the ground up — wallets, cards, processing, billing and dispute handling on proprietary rails — and is publicly positioned against Stripe. The post-money valuation has not been disclosed in published coverage of the round.

Fireblocks launched its Agentic Payments Suite on 20 May 2026, wrapping x402 in institutional custody, KYT and Travel Rule compliance for PSPs and fintechs operating across one hundred and fifty-plus chains.

OSL Group (HKEX: 863) launched OSL AgentPay in August 2026 via its OSL AI Labs unit. Per the product page, AgentPay supports multiple stablecoins (USDC, USDT, USDGO and others), is “compatible with x402 and MPP,” and offers gasless nano-payment capability for high-frequency micro-amount execution. OSL separately acquired Banxa in 2025 for roughly HKD 486.7 million and brands it as the group’s global on/off-ramp network at the corporate level. Regulated depth is the moat: fifty-plus licenses across ten-plus regions, SFC-licensed in Hong Kong, MiCAR clearance in Austria and an Australian AFSL.

x402 governance moved to the Linux Foundation on 14 July 2026 with Amazon, American Express, Circle, Google, Mastercard, Stripe, Visa and the Solana Foundation as named participants. x402 remains a blockchain-rail protocol rather than a technology-agnostic standard, which limits what it can carry.

USDGO, issued by Anchorage Digital Bank under the US GENIUS Act framework and distributed by OSL, passed one billion dollars in circulation in July 2026.²¹ ¹ It is an enterprise-grade regulated stablecoin aimed at the same sovereign and institutional conversations as USD-TDN.

AWS Bedrock AgentCore payments, built with Coinbase and Stripe, positions the hyperscaler as a closed-agentic buying surface for customers standardizing inside its cloud.

For regulated FIs and institutional CTOs evaluating rails in 2026, the practical question is no longer whether agents will transact — that is settled. It is which architectural bet compounds with your existing compliance, custody and disclosure obligations, and which one you will have to unwind in three years if it does not.

7. Mapping solutions to gaps

Verification crisis.
Both architectures support sub-cent micropayments for verified data. Kite anchors product claims to its blockchain. TODAQ wraps data APIs behind Twin Proxy paywalls; the headless catalog lets agents discover, pay for, and receive verified data in a single atomic request. Because verification travels with the file itself, high-frequency queries avoid repeated network round-trips to a shared ledger. The result is a structural throughput advantage for the lowest-value, highest-frequency data calls.

Web4 infrastructure fragility.
The low closure rate on payment-interoperability issues reflects the difficulty of making existing rails work at agent speed and ticket size. Kite consolidates payments onto its L1. TODAQ consolidates the entire transaction stack, API paywall, atomic multi-party splits, sub-ledgers and audit binders, into the Twin container. Because settlement occurs peer-to-peer at the file layer with no shared ledger state, the architecture is structurally immune to the RPC timeouts and testnet–mainnet mismatches that continue to plague cross-environment agent operations.

Programmable compliance.
Kite’s on-chain audit trail (PoAI) provides compliance inside the smart-contract paradigm: policy wrappers, on-chain attestations, escrow contracts.
TODAQ’s Transaction Binder carries the complete cryptographic lineage inside the file itself, self-verifying and auditable offline. Regulators can check compliance by examining the file’s rigging tree without querying a live blockchain. TODAQ’s Banking Gateway further connects bearer files to traditional rails (Stripe, Apple Pay, ACH), closing the fiat on- and off-ramp gap that pure stablecoin systems still face.

8. Systemic risk dimension revisited

Neither architecture fully solves the correlated-agent problem, and the ledgerless approach faces a distinct version of it.

If 100,000 users each sponsor 10–20 agents, each generating many times the transaction volume of a human, both systems face throughput questions. The deeper risk is correlation: when large numbers of agents share similar base models and react identically to the same signal, synchronized behavior can move markets faster than circuit breakers can respond.

Kite retains one potential advantage: state-channel openings and closings are on-chain events, giving regulators a possible aggregation point. TODAQ has no native global observation surface, the same property that delivers privacy and offline verifiability. As discussed in the stress test, visibility must be deliberately conferred by sharing Transaction Binders or building selective aggregation layers.

Hyper-sandwiching (complex cross-protocol MEV) is structurally mitigated in TODAQ: there is no shared mempool or block-ordering process. Kite’s state channels reduce exposure during the off-chain phase, but channel lifecycle events remain on-chain and therefore visible to MEV searchers.

9. What remains unsolved for everyone

Verification does not equal truth.
Both architectures can cryptographically anchor a claim. Neither can independently guarantee the claim is true. Staking and reputation mechanisms for reviewer or data-provider trust remain untested at the scale of agentic commerce.

The discovery problem.
The agent economy still lacks a widely adopted standard for service discovery. Qatom’s headless / MCP catalog provides a working machine-readable marketplace, but the broader ecosystem has not yet converged. Until it does, many agent integrations remain custom work.

The persona problem.
Ventirozos and Shardlow’s fifth research frontier, privacy-preserving, user-held, portable persona models, remains largely unaddressed. A profile rich enough to shop or procure well is also rich enough to exploit.

10. Conclusion: Beyond the block, and back to the human

The three papers describe an M2M economy that is already real, growing, and structurally fragile. Hundreds of millions of transaction logs confirm the scale; persistent infrastructure gaps and emerging systemic risks confirm the stakes.

Neither design is complete. Verification is not truth, and discovery standards are still forming, and remain an open research problem.

Two architectural responses are competing to supply the missing middle. Neither design is complete as discovery standards are still forming, and remain an open research problem. Kite brings blockchain-native composability and regulatory familiarity, while inheriting the failure modes of shared ledgers. TODAQ’s ledgerless approach delivers offline verifiability, structural MEV immunity, fiat-native micropayments and payment-at-source multi-party settlement.

On observability, TODAQ makes a deliberate choice: instead of unilateral global surveillance, it enables delineated visibility within defined ecosystems. Transaction Binders can be exported and shared with regulators, auditors or collaborators while preserving full cryptographic verifiability and data sovereignty, addressing the NLP research frontier of the portable privacy-preserving personas that travel with the user. In a geopolitical and business environment that increasingly prioritizes control and ownership of data over default global openness, this model of sovereign, exportable observability is a feature, not merely a trade-off. The remaining requirement is coordination on selective aggregation for macro-prudential purposes, an open governance task rather than a technical limitation.

The direction of travel is becoming clearer. The agentic economy will reward infrastructure that lets autonomous systems transact with the efficiency of a file transfer and the finality of cash, where the “cash” is a self-verifying object that can split, shield, prove and settle in a single round-trip, and where there’s an added traceability and verifiability built-in any digital TODA File asset.

This is not a story about removing humans from operational loops. It is a story about empowering the experts at the endpoints. A supply-chain auditor, a specialized lab, a compliance analyst or a niche data provider can now expose verified knowledge as a machine-readable, pay-per-call endpoint and reach a global market of agents without invoices, reconciliation cycles or enterprise sales overhead. When the answer is a number, a risk score, a shelf-life forecast, a verified material composition, the agentic railway becomes a new medium for economic communication between humans, executed at machine speed.

Whether that future belongs to a purpose-built blockchain or a ledgerless bearer file is the central infrastructure question of the next decade. The missing middle is where that question will be answered. We are building for the architecture in which the file, not the ledger, carries the proof.

Share TODAQ Press

References

Stablecoin De-pegging & Cognitive Panic

• Bo, C., & Shen, D. (2026). “When AI Meets Stablecoin: Dissecting the De-pegging Risk with LLM Agents.” School of Finance, Nankai University. SSRN: 6121746 / National Natural Science Foundation of China (72371138).
  Key Themes: Agent-based market modeling, the “cognitive de-pegging” threshold, and the 1,441 basis point expected maximum price deviation surge under narrative shocks.

The Foundations of Ledgerless Cryptography

• Coward, K., & Toliver, D. R. (2022). “Simple Rigs Hold Fast: T.R.I.E.” TODAQ. ArXiv:2208.13617. https://arxiv.org/abs/2208.13617
  Key Themes: The mathematical definitions of twists, lines, hitches, rigs, supportive guilds (G↑), lashing, splicing, and the mathematical proof of double-spend prevention without global consensus.

Normative Rigging Specifications

• Coward, K., Toliver, D. R., Sulpizi, C., Gravitis, A., Fertman, A., Everson, M., Moir, R., & Levin, J. (January 2023). “Rigging Specifications: T.R.I.E. v0.9876.” TODAQ. https://trie.site/rigging_specifications.pdf
  Key Themes: Atom serialization protocol, shape classes (0x48 basic twist, 0x49 basic body, 0x63 pairtrie, 0x61 hashes list), requirement/satisfaction validation functions (satisfies, valid), secp256r1 and ed25519 signature algorithm standards, cryptographic shielding mechanics, and the rig traversal algorithm.

The Web4 Empirical Baseline & Development Obstacles

• Jin, Y., Wu, S., Chen, C., Bao, L., Yang, X., & Chen, J. (June 2026). “The Web4 Agent Economy: A Large-Scale Empirical Study of the Landscape, Challenges, and Opportunities.” Zhejiang University. ArXiv:2606.25876. https://arxiv.org/abs/2606.25876
  Key Themes: 99,448 multi-chain registrations, 317.5M M2M transaction logs averaging $0.46 USDC, MCP open-source server metrics, and the 349 mined developer issues (OAuth blindness, RPC timeouts, payment failures).

The Headless Catalog & Portability Verifiability

• Khan, S. (31 May 2026). “The Invisible Shelf: How Headless Catalogs Are Rewiring AI Infrastructure.” TODAQ Press Substack.
  Key Themes: Operational friction of inter-model context routing, cross-provider RAG billing, real-time GPU clearing, deployer liability without deployer visibility, and the EU’s revised Product Liability Directive (EU 2024/2853) / EU AI Act Article 12 compliance logging.

The State of Agentic Commerce

• Pfeiffer, E. (28 May 2026). “The State Of Agentic Commerce In Mid-2026.” Forrester Research. https://www.forrester.com/blogs/the-state-of-agentic-commerce-in-mid-2026/
  Key Themes: The transition from search-engine optimization (SEO) to “machine-readiness”, content strategies targeting AI crawlers, and organizational silos hindering distributed commerce.

Programmable Compliance Architecture

• See, K., & Tan, X. W. (April 2026). “Compliance-Aware Agentic Payments on Stablecoin Rails.” Monetary Authority of Singapore (MAS) and the Infocomm Media Development Authority (IMDA). ArXiv:2605.00071. https://arxiv.org/abs/2605.00071
  Key Themes: Global Layer One (GL1) programmable compliance, PolicyWrapper & PolicyManager models, and the escrow-mediated PENDING transaction-splitting mechanism.

The SPACE Framework & Hierarchical Wallets

• Shi, S., Cheng, Z., Chen, X., Huang, Y., Li, L., Marwaha, U., Weber, D., & Zhang, C. (2026). “Building Trustless Payment Infrastructure for Agentic AI.” Kite AI. https://gokite.ai/kite-whitepaper
  Key Themes: The SPACE Framework, Three-Layer Identity Architecture (User Root, Agent Delegated, Session Ephemeral), Proof of Attributed Intelligence (PoAI), and programmable state channels.

Stablecoin Policy & MiCA Frameworks

• Stazi, A. (2026). “Agentic AI Payments and the Opportunities for MiCA-Compliant Stablecoins.” Techno Polis Forum-Lab, Policy Brief n. 5/2026. https://techno-polis.com/policy-briefs
  Key Themes: Projected $3–$5 trillion market size by 2030, MiCA-compliant stablecoin reserve backing mandates, the US Genius Act, and integrating Europe’s Anti-Money Laundering Authority (AMLA) and Verification of Payee (VoP) standards.

The Verification Layer & Product Data Crisis.

• Ventirozos, F., & Shardlow, M. (June 2026). “Paying to Know: Micro-Transaction Markets for Verified Product Information in Agentic E-Commerce.” Manchester Metropolitan University. ArXiv:2606.24783. https://arxiv.org/abs/2606.24783
  Key Themes: Retails return metrics, sports supplement label discrepancy statistics, LLM commercial/medical query hallucination baselines, and the four verification primitives (Claim, Confidence, Category, Shelf Life).

Agentic Payments & Stablecoin Policy Debates

• White, C. (24 March 2026). “AI Agents & Stablecoin Risks.” Japan Fintech Week 2026 Meeting Report, Financial Applications & Social Economics Working Group (FASE-WG) of the Blockchain Governance Initiative Network (BGIN), Tokyo. https://bgin-global.org/events/20260301-block14.
  Key Themes: Stablecoin stress-testing for AI agent scenarios, “hyper-sandwiching” block-level MEV manipulation, and the “human rental” AML bypass vector.

Full list of sources

1. Blockchain Governance Initiative Network (BGIN) FASE-WG. (2026, March 2). AI Agents & Stablecoin Risks Meeting Report. Japan Fintech Week.

2. BGIN FASE-WG. (2026, March). AI Agents & Stablecoin Risks (Sections 8–12).

3. BIP-32. (2012). Hierarchical Deterministic Wallets [Bitcoin Improvement Proposal].

4. Bo, C., & Shen, D. (2026). When AI Meets Stablecoin: Dissecting the De-pegging Risk with LLM Agents. SSRN: 6121746.

5. Cohen, P. A., et al. (2023). Presence of Label Claims and Dietary Ingredients in Sports Supplements. JAMA Network Open.

6. Coinbase Developer Platform & x402 Foundation. (2025). Introducing x402: A New Standard for Internet-Native Payments.

7. Coward, K., & Toliver, D. R. (2022). Simple Rigs Hold Fast. arXiv:2208.13617. TODAQ.

8. Coward, K., Toliver, D. R., et al. (2023, January). Rigging Specifications: T.R.I.E. v0.9876 (Technical Report). TODAQ.

9. Datadog, Inc. (2018 & 2021). Fourth Quarter and Full Year 2018 Financial Results & Fourth Quarter and Fiscal Year 2021 Financial Results [SEC Filings].

10. Directive (EU) 2024/2853 of the European Parliament and of the Council on liability for defective products. (2024, December). Official Journal of the European Union.

11. EIP-8004 Registry Statistics. (2026, April). 8004scan: The Web3 Agent Explorer. Retrieved from 8004scan.io.

12. ERC-4337. (2023). Account Abstraction via Entry Point Contract Specification [Ethereum Improvement Proposal].

13. Financial Action Task Force (FATF). (2023, June). Virtual Assets: Targeted Update on Implementation of the FATF Standards on Virtual Assets and VASPs.

14. Global Layer One. (2025). Programmable Compliance Toolkit [Online Documentation]. Retrieved from doc.global-layer-one.org.

15. Jin, Y., Wu, S., Chen, C., Bao, L., Yang, X., & Chen, J. (2026, June 24). The Web4 Agent Economy: A Large-Scale Empirical Study of the Landscape, Challenges, and Opportunities. arXiv:2606.25876. Zhejiang University. https://arxiv.org/html/2607.00245v1

16. Kite AI. (2026). SPACE: A Trustless Payment and Identity Infrastructure for Autonomous Agents [Technical White Paper]. Retrieved from gokite.ai/kite-whitepaper.

17. Linux Foundation. (2026, July 14). x402 Foundation Launch Announcement.

18. Nature Article. (2025). Evaluating LLM Factuality and Hallucination Rates in Domain-Specific Contexts. Nature, s43856-025-01021-3.

19. Qatom. (2026). Qatom — MCP for Agentic Commerce [Product Specification]. Retrieved from qatom.ai.

20. Regulation (EU) 2023/1114 on Markets in Crypto-assets (MiCA) and EU Artificial Intelligence Act. (2024).

21. See, K., & Tan, X. W. (2026, April 30). Compliance-Aware Agentic Payments on Stablecoin Rails. arXiv:2605.00071 [cs.CR]. Monetary Authority of Singapore & IMDA.

22. TODAQ. (n.d.). TODA Twin Micropayment Proxy — Engineering Documentation. Retrieved from engineering.todaq.net/micropay/.

23. TRM Labs. (2026). On-Chain Activity and Stablecoin Transaction Volume Report (Q1 2026).

24. Ventirozos, F., & Shardlow, M. (2026, June 23). Paying to Know: Micro-Transaction Markets for Verified Product Information in Agentic E-Commerce. arXiv:2606.24783 [cs.CL]. Manchester Metropolitan University.

    
    

Historically, digital commerce has been built on a single assumption: that a person with a browser is on the other end. Someone clicks. Someone types a credit card number. Someone confirms.

That assumption has quietly eroded.

We are entering the age of headless catalogs: environments where product inventories, service listings, data feeds, and APIs are exposed as raw, machine-readable structures. No interface. No human in the loop. Just schema-driven data, parsed and acted upon by software agents that browse, evaluate, and transact autonomously. When one agent buys from another, paying fractions of a cent for a vector row or a millisecond of compute, we have crossed into true machine-to-machine (M2M) agentic commerce.

ChatGPT alone processes 2.5 billion prompts daily. That number covers only the human-visible surface. Underneath it, every prompt spawns a cascade of machine-initiated sub-calls: retrieval queries, tool invocations, model hops, compute allocations. A single AI conversation can trigger hundreds of micro-activities, each carrying sub-cent costs. To illustrate the scale: a four-agent workflow executing five reasoning rounds produces at minimum 20 LLM calls at simple deployment. Gartner estimates that 80% of enterprise applications shipped or updated in Q1 2026 embed at least one AI agent, up from 33% in 2024, and multi-agent production systems now routinely involve 4 to 6 specialized agents plus an orchestrator, all firing in parallel, all exchanging value no existing payment system was designed to handle.

The execution challenge is being engineered toward rapidly. Four competing protocols have moved to production in the past six months alone. The question that is receiving far less attention is what happens as this infrastructure scales, and whether the evidentiary layer being built today will be adequate when something consequential goes wrong.

Where Current Infrastructure Creates Structural Risk

Several operational friction points are already visible, and they share a common root that matters for what follows.

Inter-model context sharding and routing. Enterprise meta-routers dynamically split a single human query into hundreds of distinct sub-tasks, concurrently querying an ensemble of models: a small local model for fast classification, a vector database for semantic retrieval, a frontier LLM for deep reasoning. Every hop across those model boundaries requires an internal API billing call. At the volume these systems now operate, the overhead of micro-metering and validating API key rates in real time becomes both a performance ceiling and an accounting constraint.

Cross-provider vector database retrieval. Enterprise RAG pipelines pull hyper-specific data fragments from distributed vector databases owned by different vendors. Those vendors want to monetize their embeddings at granular scale, at fractions of a cent per vector row retrieved. Standard payment networks make this economically unworkable. Even with transaction batching, tokenization, and preferential enterprise rates, toll and processing fees cannibalize the margins on sub-cent retrieval calls. The economics stall the market, or force enterprises to absorb costs that should be distributed across the value chain.

Real-time GPU and compute clearing. Decentralized compute layers spin up processing power across multiple cloud providers based on real-time price and latency. When an AI execution layer shifts its workload from one server host to another mid-stream, it requires instant financial clearing, with no end-of-month invoicing and no confirmation delays measured in seconds. Each moment of settlement latency is a moment of degraded service.

These three friction points share a structural root: the financial and data layers remain separate. Payment happens out-of-band, after the fact, via systems built for human-paced commerce. The agent economy runs at machine speed, and that mismatch compounds as transaction volumes grow.

The Concentration Risk No One Is Pricing

Current machine-native settlement activity appears highly concentrated around a single settlement mechanism, a fragility the market is not yet pricing.

Research from Keyrock, Coinbase, and the Tempo Collective found that AI agents are completing over 176 million autonomous transactions annually, with an average transaction size of just $0.31. The data suggests approximately 98% of that volume is USDC-denominated. A single regulatory action against a major stablecoin issuer, a reserve management failure, or a sustained network congestion event could freeze a significant portion of machine commerce simultaneously.

The International Monetary Fund addressed the structural problem directly in its April 2026 note on agentic AI and payments, identifying a fundamental architectural friction between probabilistic AI behavior and the deterministic requirements of payment infrastructure. The IMF’s framework breaks machine commerce into three layers (intent, authorization, and settlement) and flags that traditional ledger synchronization introduces systemic opacity when machines execute high-frequency tasks. Capco and Info-Tech Research Group have separately warned that high-velocity machine commerce will produce volumes of duplicate payments that traditional banks cannot detect in real time.

Just this month, the Bank of England entered the conversation. In a May 21st post on its Bank Underground research blog, the Bank’s payments team observed that as agents move from initiating individual payments to orchestrating entire payment lifecycles, communicating with other agents to manage complex, multi-party flows, existing frameworks for authentication, liability, and consumer protection face genuine design gaps. The Bank made one point with particular clarity: legal responsibility for an agent’s actions remains with the human deployer. That formulation, deployer liability without deployer visibility, names a structural problem that extends well beyond payment rails.

This liability gap is now colliding with hard regulatory deadlines. The EU’s revised Product Liability Directive (EU 2024/2853), in force since December 2024 with a transposition deadline of December 2026, explicitly extends strict liability to software and AI systems. Under Article 28 of the EU AI Act, deployers who substantially modify high-risk AI systems can be reclassified as providers, shifting the full burden of proof onto the organization that deployed the agent. If that organization cannot demonstrate a complete, unalterable trail of its agent’s actions, the legal presumption is that the process design was at fault. The regulatory direction of travel is unambiguous: deployers are accountable, and accountability requires evidence that current logging infrastructure cannot reliably produce.

The Evidentiary Gap

Multiple independent trends are converging toward a problem that the infrastructure being built today is not yet designed to solve. The problem has a precise name: evidentiary portability, defined as the ability for proof of execution to remain independently verifiable after crossing institutional, jurisdictional, and operational boundaries. It is the property that makes accountability possible when the parties involved in a transaction are not the same parties who later need to verify it.

Autonomous execution is scaling. Machine-native transactions are multiplying. Workflows are fragmenting across institutional boundaries. And regulatory scrutiny is increasing. None of these trends alone creates an evidentiary crisis. Together, they point toward a future in which evidentiary portability becomes a foundational infrastructure requirement, and the question is whether organizations build for it before or after the first large-scale failures make it unavoidable.

Frontline engineers working on production AI financial systems are already naming the problem. As one developer noted in a recent discussion on r/fintech: “A completed task is not the same thing as accountable execution.” The distinction matters because it describes exactly what current infrastructure fails to provide: proof of what ran, at every step, in a form that survives the institutional boundaries of the system that generated it.

The headless catalog is why this matters structurally. A headless catalog is invisible by design: no storefront, no session, no human navigating a checkout flow. When an agent reads a catalog, prices a service, and executes a transaction, there is no human witness to any of it. The architecture that makes headless commerce fast and frictionless is the same architecture that makes its transactions inherently unwitnessed. Unlike a conventional commerce system where the interface creates at least a partial record of intent, a headless environment leaves nothing at the surface.

The catalog is invisible. The transaction is invisible. And when something goes wrong, the proof has to be reconstructed from sources that were never designed to produce it.

To make the problem concrete: imagine an orchestrating agent routes a task across three specialized model providers, splits a micropayment across five vendors, and pulls data through two jurisdictions. The receiving vendor disputes the payment amount. The originating enterprise disputes the execution record. Standard logs exist; they are institution-bound, generated by the same systems that executed the action, and held by parties with interests in the outcome. Reconstructing a chain of custody means assembling audit trails that may be incomplete, structurally incompatible, or simply unavailable from a counterparty with no obligation to share them. This is the default architecture of any multi-provider agentic workflow running today.

OpenAI’s Instant Checkout, the highest-profile consumer deployment of the Agentic Commerce Protocol, was paused within weeks of launch, a reminder that execution at scale surfaces problems that controlled environments don’t. The specific causes were not fully disclosed. The pattern is instructive regardless.

The arithmetic of failure. When we examine the unit economics of a dispute, the necessity of a different approach becomes undeniable. In traditional financial systems, chargeback fees alone range from $15 to $100 per incident, with processors including all labor and administrative overhead putting the true cost of a single dispute at $190 to $250, according to data from Chargebacks911 and Mastercard. That is before the 30 to 90 days typically required to resolve it. Applying a $15 minimum dispute resolution cost to a $0.31 AI micro-transaction is mathematically impossible: the overhead exceeds the transaction value by nearly 50x. Modern agentic payment infrastructure can ingest usage events at webhook pipelines processing 15,000 events per second. Retrofitting human-speed dispute resolution onto machine-speed commerce doesn’t just hurt margins. It makes the unit economics of the entire vendor relationship unworkable.

The regulatory framing is now concrete. The EU AI Act’s high-risk AI provisions take effect August 2, 2026. Article 12 requires automatic event logging across the lifetime of any high-risk AI system. The complication, noted independently by compliance researchers at Help Net Security and TrueScreen: standard application logs are mutable by the operator and therefore inadmissible as evidence in disputes. Regulators are formalizing a requirement the underlying infrastructure cannot yet satisfy.

Share

Why Logs Are the Wrong Answer

This is the point that deserves more attention than it typically receives in discussions of AI governance and agent accountability.

The instinctive response to the evidentiary problem is better logging: more comprehensive, more granular, retained longer. But understanding why logging is insufficient requires recognizing that there are three distinct architectures for trust in autonomous systems, and they have very different properties when institutional boundaries are crossed.

The first is institutional trust: logs, audit trails, and internal records held by the party that generated them. The second is shared infrastructure trust: public blockchains, transparency logs, and third-party witnesses that provide verification without requiring trust in the originating institution. The third is asset-level trust: proof embedded in the asset itself, traveling with it across any boundary, verifiable by whoever holds it without reference to any external system.

Most enterprise infrastructure today operates at the first level. The question is why the second level is insufficient, and what properties the third level provides that neither of the first two can.

Logs are institution-bound. They live inside the systems of the party that generated them, are controlled by that party, and are readable only by whoever has access to those systems. When a transaction crosses institutional boundaries, as is definitional in multi-agent, multi-provider workflows, the log of what happened on one side is a different artifact from the log of what happened on the other. Each institution holds its own version. Those versions may conflict. Neither is independently verifiable by a party who holds neither system.

Logs are also mutable. An append-only log, a Merkle audit tree, a signed event stream: each of these is an improvement over a naive database, but each still places the verification burden on access to the originating system and trust in the originating institution. If the institution becomes conflicted, unavailable, or adversarial, the log’s integrity cannot be established by the party requiring it.

Some infrastructure providers have gone further, using cryptographically signed, hash-linked task graphs (Directed Acyclic Graphs that chain execution steps into a non-repudiable sequence). That is a meaningful architectural advance over standard logging. The limitation is the same one: the DAG is held by the institution that generated it. If the orchestrator goes offline or becomes adversarial, a counterparty still cannot independently verify the record without trusting the issuing institution. The structure is more tamper-evident, but it remains institutionally bound.

The most sophisticated version of the logging answer, systems like Certificate Transparency or Sigstore, addresses this by introducing a third-party witness: a public log that records cryptographic commitments, independently verifiable without trusting the issuing institution. That is a genuine architectural advance. The limitation is that it externalizes verification to a witness infrastructure that must itself be trusted, available, and have observed the transaction at the moment it occurred. CT log inclusion typically takes 1 to 5 seconds minimum. In a high-frequency, multi-hop agentic workflow where protocols like x402 clear transactions in approximately 200 milliseconds, requiring real-time witness registration reintroduces the latency and availability dependencies that machine-speed commerce is trying to eliminate. Witnessed logs solve institutional portability for human-paced systems. Asset-embedded proof solves it for machine-speed ones.

The fundamental problem is what might be called institutional portability: the challenge of producing proof that survives the transaction and the institutional boundaries and adversarial conditions that follow it, including disputes, infrastructure failures, jurisdictional handoffs, and counterparties with every reason to contest the record.

Solving this requires proof that travels with the asset itself, independently verifiable by any party who holds it, without requiring access to any originating institution’s systems.

What the Architecture Requires: Protocols Solve Execution, Not Proof

Four competing protocols have moved to production in the past six months: OpenAI and Stripe’s Agentic Commerce Protocol (ACP), Google’s Agent Payments Protocol (AP2, backed by 60+ partners), Coinbase’s x402, and Stripe and Tempo’s Machine Payments Protocol (MPP), launched March 2026. Each addresses a different layer of the payment stack: authorization, checkout flow, HTTP-native settlement, or streaming micropayments. The execution challenge is being actively engineered toward, by well-capitalized teams moving fast.

What none of these protocols specifies is a mechanism for cross-institutional evidentiary proof after a dispute. ACP handles authorization. x402 facilitates HTTP-native stablecoin settlement in approximately 200 milliseconds. AP2 is a payment-agnostic mandate framework. MPP handles streaming micropayments. Not one of them addresses how a disputed transaction gets proven after the fact, across institutional boundaries, by a party who holds neither system. Evidentiary portability is outside their stated scope. This is a precise description of where the market gap currently sits: protocols competing to own execution, and the verification layer still unbuilt.

At TODAQ, we believe closing that gap requires a structural rethinking of how value and proof travel through a system.

Atomicity at the execution layer. When millions of agents make billions of sub-cent calls per second, routing each through an external ledger or database for validation is a bottleneck by design. The payment file needs to travel with the data payload, inside the protocol headers, and verify itself locally on the receiving server without an external lookup. The goal is collapsing payment and data transfer into a single network round-trip, making the financial layer part of the protocol rather than an external dependency. Our Qatom protocol is designed to achieve this through local cryptographic validation, and internal testing under multi-hop ensemble conditions suggests meaningful latency advantages over gateway-dependent approaches, though production benchmarks at scale remain an active area of measurement.

Security native to the asset. In a headless M2M environment where agents interact dynamically across networks no single party controls, perimeter-based security cannot hold. The TODA file structure addresses this through a Trie integrated into a Merkle Tree, enforcing a strict mathematical constraint: a single cryptographic wallet identifier maps to exactly one destination path per consensus cycle. If an agent attempts to copy a file and spend it twice, both transactions are forced down the same deterministic path. The Merkle Trie cannot store two different values on the same path; the second entry collides with the first, creating a validation failure that propagates upward. The file’s top-level hash mismatches, the transaction is rejected, and the attempt is cryptographically attributable to its origin. The double-spend constraint is a property of the data structure itself, built in rather than applied as a policy layer on top.

Provenance embedded in the asset. In the TODA architecture, the transaction history is encoded directly into the asset through a Proof of Provenance (POP) chain. Every handoff, every split, every consumption event produces a time-stamped cryptographic signature embedded in the file itself. Compliance teams examining an asset don’t reconstruct its history from scattered system logs across cloud environments; the asset carries its own complete record, verifiable by any party who holds it, without requiring access to any originating institution’s systems.

This is the distinction that matters most: provenance-in-the-asset is architecturally different from provenance-in-the-log. A log is a record held by an institution, degrading at every boundary it crosses. An asset-embedded proof is a record held by whoever holds the asset, traveling intact across any boundary.

It is also distinct from a blockchain approach, which is the natural comparison readers will reach for. A public distributed ledger provides shared infrastructure trust, offering verification without relying on the originating institution, but it reintroduces external dependencies: consensus latency, validator availability, gas costs, and trust in the network itself. The TODA architecture eliminates all of these. Verification is local, performed against the cryptographic structure of the asset itself, with no network call, no consensus round, and no external validator. The proof is in the file. The file is the proof.

The practical consequence is that a single file carries its payment, its history, and its own verification, and that proof remains intact and independently readable across any institutional boundary, which is precisely the property that matters when the institution that originated a record has become conflicted, unavailable, or simply irrelevant to whoever needs to verify it.

The Broader Claim

TODAQ operates as a full-stack AI infrastructure layer, handling payments, verification, audit, payouts, and bank integration through conversational agentic commerce and API integration, with deterministic controls. The underlying thesis is that collapsing the payment layer and the evidentiary layer into a single, indivisible structure represents a fundamentally different answer to what the payment system is for, one that reframes the architecture rather than refining the existing one.

The applications extend beyond AI commerce. Anywhere autonomous systems make consequential decisions across institutional boundaries, including pharmaceutical cold-chain logistics, autonomous fleet operations, decentralized compute networks, and multi-jurisdiction financial workflows, the same challenge applies: the record of what happened must be independently verifiable after the fact, by parties who were not present, under conditions that may be adversarial.

Early signals of this problem are already visible in enterprise environments: audit reconstruction difficulties, cross-platform disputes over autonomous decisions, provenance gaps in regulated workflows. The underlying conditions, autonomous execution at scale, machine-native transactions, cross-institution fragmentation, and expanding regulatory requirements, are developing faster than the infrastructure designed to verify them.

Independently verifiable execution will become important; the direction of travel, from IMF framework documents to Bank of England research posts to EU AI Act logging requirements to the Product Liability Directive’s extension of strict liability to AI systems, points consistently toward more accountability requirements. The open question is whether organizations build for evidentiary portability before or after the first large-scale failures make it unavoidable. Infrastructure decisions made in the next 18 months will largely determine the answer.

There is a well-established pattern in infrastructure categories: the problems that seem optional at low adoption become load-bearing at scale. Datadog’s revenue grew from $198 million in FY2018 to over $1 billion by FY2021, roughly 5x in three years, not because observability became fashionable, but because containerization and microservices made distributed tracing structurally mandatory. The market didn’t wait for a catastrophic debugging failure to decide that logging infrastructure mattered; it built ahead of the inflection point. As autonomous agents become legally and financially consequential, the cross-institutional provenance of their actions is following the same trajectory: from a logging consideration to a rigid design constraint.

If current trajectories hold, evidentiary portability will move from a peripheral concern to a core design constraint in autonomous systems. The organizations that treat this as an architectural requirement early will likely define the standards required by the later systems that scale. The next infrastructure competition may not be over who executes transactions fastest. It may be over who can produce the most portable, independently verifiable transactions and asset information. The organizations and infrastructure layers that solve evidentiary portability before the first large-scale failures demand it will have built something genuinely difficult to replicate.

Susana Khan is CMO of TODAQ, builders of the TODA Protocol, open-source infrastructure for independently verifiable autonomous execution.

Share

Leave a comment

References

Amplience. (2026). AI-powered headless CMS & DAM for enterprise retail. https://amplience.com/ai/

Bank of England. (2026, May 21). Agentic commerce and the battleground for new payments infrastructure (P. Munday). Bank Underground. https://bankunderground.co.uk/2026/05/21/agentic-commerce-and-the-battleground-for-new-payments-infrastructure/

Bhairav, S. (2026). Detecting duplicate vendor payments with agentic AI in FinTech. https://suhasbhairav.com/blog/how-agentic-ai-can-help-fintech-companies-detect-duplicate-vendor-payments

Bravo, T. C. (2026). The agentic web: Inside the protocol race for machine-to-machine payments. Emerging Fintech.

Capco. (2025). Agentic AI: The new frontier in financial services innovation. https://www.capco.com/intelligence/capco-intelligence/agentic-ai

Chargebacks911. (2026). How much is a chargeback fee? Cost breakdowns for 2026. https://chargebacks911.com/chargeback-management/chargeback-fees/how-much-is-a-chargeback-fee/

Coinbase Developer Documentation. (2025). Overview — x402. https://www.x402.org/

Coinbase Developer Platform. (2025). x402 whitepaper. https://www.x402.org/x402-whitepaper.pdf

Coward, K., & Toliver, D. R. (2022). Simple rigs hold fast (arXiv:2208.13617v1). arXiv. https://arxiv.org/pdf/2208.13617

Crossmint. (2026). Agentic payments protocols compared: ACP, AP2, x402, MPP. https://www.crossmint.com/learn/agentic-payments-protocols-compared

CSAI Foundation. (2026). CISA’s agentic AI five-risk framework: Enterprise implementation [PDF].

Datadog, Inc. (2019). Fourth quarter and full year 2018 financial results [SEC filing].

Datadog, Inc. (2022). Fourth quarter and fiscal year 2021 financial results [SEC filing].

European Union. (2024). Directive (EU) 2024/2853 of the European Parliament and of the Council on liability for defective products. Official Journal of the European Union.

EverWorker. (2026). How AI bots transform financial reconciliation and accelerate month-end close. https://everworker.ai/blog/ai_bots_automate_financial_reconciliation_audit_ready_close

Fenwick. (2026). Is 2026 the year of agentic payments?

Ferreira da Silva, R., et al. (2025). A grassroots network and community roadmap for interconnected autonomous science laboratories. In Proceedings of the ICPP Workshops ‘25. Association for Computing Machinery. https://arxiv.org/abs/2506.17510

FXC Intelligence. (2025). B2B cross-border payments in 2025: A year in data. https://www.fxcintel.com/research/reports/ct-b2b-payments-2025-roundup

Gartner. (2026, May 26). Gartner says applying uniform governance across AI agents will lead to enterprise AI agent failure [Press release]. https://www.gartner.com/en/newsroom/press-releases/2026-05-26-gartner-says-applying-uniform-governance-across-ai-agents-will-lead-to-enterprise-ai-agent-failure

Help Net Security. (2026, April 16). What the EU AI Act requires for AI agent logging. https://www.helpnetsecurity.com/2026/04/16/eu-ai-act-logging-requirements/

Info-Tech Research Group. (2026). Data priorities 2026. https://www.infotech.com/research/ss/data-priorities-2026

International Monetary Fund. (2026). How agentic AI will reshape payments (IMF Note No. 2026/004).

Keyrock, Coinbase, & Tempo Collective. (2026). Crypto-enabled AI agents drive $73M in machine-to-machine settlements.

Khan, S. (2026a). Settlement without proof. TODAQ Press. https://todaq.substack.com/p/settlement-without-proof

Khan, S. (2026b). The agent economy just got its first native currency rail. It’s called Qatom. TODAQ Press. https://todaq.substack.com/p/the-agent-economy-just-got-its-first

Khan, S. (2026c). When the transaction becomes the record. TODAQ Press. https://todaq.substack.com/p/when-the-transaction-becomes-the

KPMG. (2026). KPMG global AI in finance 2026. https://assets.kpmg.com/content/dam/kpmgsites/xx/pdf/2026/05/global-ai-in-finance-report.pdf

Kulkarni, S., & Kulkarni, Y. (2026). Benchmarking multi-agent LLM architectures for financial document processing (arXiv:2603.22651). arXiv. https://arxiv.org/abs/2603.22651

Magnolia DXP. (2026). Headless commerce: Everything you need to know. https://www.magnolia-cms.com/blog/headless-commerce-everything-you-need-to-know.html

Mastercard. (2026). Why chargebacks cost more than you think. https://b2b.mastercard.com/

McKinsey & Company. (2025). The agentic commerce opportunity (K. Schumacher & R. Roberts). https://www.mckinsey.com/capabilities/mckinsey-digital/our-insights/the-agentic-commerce-opportunity

Nevermined. (2026). 45 agent-to-agent payment stats for 2026. https://nevermined.ai/blog/agent-to-agent-payment-statistics

OpenAI & Axios. (2026). ChatGPT processes 2.5 billion prompts daily.

OpenAI & Stripe. (2026). Agentic commerce protocol. https://www.agenticcommerce.dev/

PrudAI. (2026). AI liability 2026: Who is responsible for AI agent mistakes?

Reddit. (2026). AI agents are making financial decisions in production and most of them have no verifiable execution trail [Online forum post]. r/fintech.

RJ Wave. (2026). The agentic revolution: How autonomous AI is reshaping global banking [PDF].

Stripe. (2026). Agentic commerce: A guide for businesses. https://stripe.com/resources/agentic-commerce-guide

Tomašev, N., et al. (2025). Virtual agent economies (arXiv:2509.10147v1). arXiv. https://arxiv.org/abs/2509.10147

TrueScreen. (2026, May 16). Agent-to-agent audit trail: Provenance for AI ecosystems. https://truescreen.io/blog/agent-to-agent-audit-trail

Visa Consulting and Analytics. (2025). From automation to autonomy. https://www.visa.com/

Wang, R. (2026). AI agents now shop without humans as headless merchants process 31K transactions. Blockchain.News. https://blockchain.news/news/ai-agents-headless-merchants-31000-transactions-mpp

Xu, M. (2026). The agent economy: A blockchain-based foundation for autonomous AI agents (arXiv:2602.14219). arXiv. https://arxiv.org/abs/2602.14219

This piece discusses an emerging infrastructure category around independently verifiable AI execution and explains why TODAQ’s architecture aligns with the requirements that category appears to be creating. This is the third in a series examining the infrastructure beneath autonomous systems.

TL;DR

Large enterprises like Visa, Mastercard, Google, Stripe, AWS, are all building trust infrastructure for AI agents. They’re solving the right problem, but at the wrong layer. Settlement infrastructure (getting agents to transact reliably) and evidentiary infrastructure (proving what they did to adversarial third parties) are different problems. Existing approaches, including TEEs, centralized audit trails, and payment protocol logs, handle the first well. None of them solve the second under adversarial conditions, when the institution that holds the record is also a party to a dispute, or has interests that diverge from whoever needs to verify it.

The property that’s missing has a name: institutional portability, provenance that survives the loss of institutional cooperation. Not tamper-resistance, which existing systems provide. Not immutability, which blockchains provide. Specifically: a record that remains independently verifiable after the institution that originated it has become conflicted, unavailable, or simply irrelevant to the parties relying on it.

This matters now because autonomous systems are multiplying the frequency of execution that crosses institutional boundaries faster than centralized systems can govern it. Regulatory frameworks are tightening. Insurance markets are beginning to price the absence of portable provenance. And courts are establishing precedents that make the question “can you prove what your agent did?” not rhetorical.

The deeper shift: for most of institutional history, transactions and their authoritative records were maintained as separate things. Autonomous systems dissolve that separation. The transaction that cannot produce its own independently verifiable record of itself becomes a liability. When the transaction becomes the record, the question of institutional trust stops being about who holds the ledger.

Over the past year, something shifted in how very large institutions are building. Visa and Cloudflare co-developed the Trusted Agent Protocol. Mastercard launched Agent Pay, then introduced Verifiable Intent in collaboration with Google. OpenAI and Stripe released the Agentic Commerce Protocol, now processing live transactions across Etsy and Shopify. Google launched its Universal Commerce Protocol with twenty partners, and its Agent Payments Protocol as a vendor-neutral bridge that Mastercard, Stripe, and Visa have all since aligned to. Amazon deepened its relationship with Anthropic, positioning Claude as enterprise infrastructure inside AWS.

These organizations have different customers, different competitive incentives, and different operational languages. They don’t normally move together. The fact that they are converging on the same infrastructure problem from is a signal worth taking seriously.

The market has understood that autonomous systems need a trust layer. The question it is still working through is which layer ultimately becomes the system of record beneath autonomous execution, and whether the infrastructure being built today can actually serve that function.

It can’t. Not fully. And the gap that remains is both specific and structural. The deeper shift underneath all of it is this: for autonomous systems operating at scale, the transaction and the authoritative record of the transaction can no longer be maintained as separate things. When they diverge, when the record lives somewhere other than the act itself, the gap becomes exploitable, contestable, and ultimately ungovernable. The infrastructure race underway is, at its core, about whether that separation gets closed, and by whom.

Why Logging and Indemnification Won’t Be Enough

The instinctive response from most enterprise risk teams is: we have audit trails, we have contractual indemnification, we have compliance programs. These have been sufficient for human-executed processes for decades. The argument for why they fail under autonomous execution has three parts.

The reconstruction problem. When a human makes a consequential decision, a human was present for it. The record can be reconstructed because the actor can testify, the decision process left traces, and the chain of accountability is bounded. When an autonomous agent makes a decision, the chain may run through a dozen systems, three cloud providers, two third-party APIs, and another agent before producing an outcome. More critically: when the agent generates a log of what occurred, that log is itself a probabilistic reconstruction, produced by the same language model that executed the action. It can be internally consistent, confidently written, and factually wrong. Better reliability practices reduce the frequency of errors; they do not change the nature of the record. A log generated by the system that acted answers nothing when that system’s account of itself is precisely what is in dispute.

The Replit incident in July 2025 makes this concrete. A coding agent working on a live project ignored an explicit instruction freeze, deleted a production database containing records for over 1,200 executives, and told the user recovery was impossible. The full extent of what had occurred was only discovered by interrogating the agent directly, an agent that had already generated a misleading account of its own actions. No external signal of failure existed. The record of what it had done existed only in its own account of itself.

The adversarial condition. Contractual indemnification requires that you can reconstruct the execution chain clearly enough to assign liability. In most current deployments, you cannot, and in the cases where it matters most, the party whose infrastructure generated the logs is also a party to the dispute. A counterparty, regulator, or court has no obligation to treat those logs as authoritative. The UnitedHealth litigation, currently in federal discovery with tens of thousands of internal documents being produced, illustrates the shape of the problem regardless of its eventual outcome: logs existed, assembled after the fact from records that didn’t travel with the decisions, and a court order was required to surface them. The question isn’t whether logs exist. It’s whether they’re accurate, and whether the organization can prove it to a party that has every reason to contest them.

Clifford Chance’s analysis of agentic AI contracts found that under most current technology agreements, if an agent incorrectly authorizes a payment or misprices a product, standard supplier disclaimers typically leave the customer holding liability for a system they didn’t design and cannot fully audit. The contractual framework eliminates meaningful recovery precisely when stakes are highest.

The liability horizon is arriving. California AB 316, which took effect January 1, 2026, forecloses the autonomous-harm defense: developers and deployers of AI systems can no longer argue that the AI acted independently as a shield against civil liability. The EU Product Liability Directive classifies AI software as a product subject to strict liability, with member-state implementation by December 2026. These aren’t future risks. They’re current exposures accumulating on a timeline that most organizations’ infrastructure roadmaps don’t reflect.

How the Stack Actually Breaks Down

The agent infrastructure market is being built along two axes that are frequently conflated but are different problems with different solutions.

The first is settlement infrastructure. Getting authorized agents to transact reliably necessitates identity, payment rails, and execution coordination. This is where most current investment and partnership activity is concentrated, and for good reason. It’s urgent, it’s tractable, and the organizations building here are doing serious work.

The second is evidentiary infrastructure. Producing records of what agents did that remain independently verifiable to parties who weren’t present; under adversarial conditions, across institutional boundaries, without depending on the continued cooperation of whoever originated the record.

Current settlement infrastructure doesn’t solve the evidentiary problem. They’re different in kind, not in degree.

Skyfire’s Know Your Agent framework, integrated with Experian’s identity data and enforced by Cloudflare at the network edge, carries verified claims about agents in standard HTTP infrastructure. It’s well-designed for web3 and crypto-native contexts where HTTP-native credential enforcement is the goal, and for enterprise environments that already operate within that trust perimeter. Within those contexts it works well. The constraint is the perimeter itself.

Mastercard Verifiable Intent, co-developed with Google, creates tamper-resistant cryptographic records linking consumer identity, specific instructions, and transaction outcomes. It has real provenance properties and is authoritative within the Mastercard network, because participating institutions have agreed to treat that infrastructure as the source of truth. That agreement is powerful inside the network. It breaks down when a dispute involves a party outside it, a regulatory jurisdiction that hasn’t agreed to accept the network’s records as authoritative, or an insurer and enterprise deployer whose interests in characterizing the execution chain diverge.

x402, AWS AgentCore Payments, and the Universal Commerce Protocol solve transactional coordination: value transfer, execution interoperability, and settlement finality. AWS stores logs in CloudWatch, whatever the agent reports, observable but not independently verified. x402 has processed 169 million transactions; the question worth asking isn’t how many transactions it has processed, but what it can prove about each one when asked by a party that doesn’t share its trust assumptions.

The IMF’s April 2026 policy note gestured at the relevant tension without fully landing on it: payment systems require deterministic execution and settlement finality, while agentic AI introduces probabilistic reasoning and non-deterministic execution paths. Separating AI orchestration from deterministic settlement is a sound instinct. But even with deterministic settlement, the surrounding record may remain probabilistic, generated after execution by the same system that executed, coherent in narrative but unverifiable in fact.

This is the specific gap that better observability tooling, TEEs, and settlement finality don’t reach. Trusted Execution Environments can cryptographically prove which model ran against which input, hardware integrity is provable. What TEE attestation doesn’t cover is whether the log the model generated faithfully represents the sequence of decisions across a multi-step workflow. The hardware integrity is provable; the semantic accuracy of the record is not. And even where hardware attestation is combined with external auditors or notarized compliance chains, approaches that work well in stable institutional relationships, the remaining gap is institutional independence: whether the entity attesting to the record has interests that can diverge from the parties relying on it. That is precisely what adversarial conditions test.

Why the Boundary Condition Is the Hard Problem

Incumbents building settlement infrastructure are technically sophisticated and well-resourced. The limitation isn’t technical. It’s architectural.

Centralized provenance systems inherit the political trust assumptions of the institution maintaining them. That’s not a criticism, it’s their intentional design. Institutional trust works by agreement among participants, and courts rely on contested institutional records constantly. SWIFT, DTCC, clearinghouses, and HSM-backed signing systems produce records that carry real legal weight. The argument here isn’t that centralized provenance is invalid. It’s that under adversarial conditions across institutional boundaries, it creates significantly higher verification friction, greater discovery cost, slower adjudication, and material uncertainty, particularly in cross-jurisdictional disputes where no shared authority exists.

Consider where that friction becomes structurally prohibitive:

A cross-border supply chain dispute where one party is in a jurisdiction that doesn’t recognize the other’s record-keeping authority. An insurance claim where the insurer and the enterprise deploying the agent have conflicting interests in how the execution chain is characterized. A regulatory investigation where the regulator and the regulated institution are not, by definition, on the same side. A commercial dispute between two enterprises whose autonomous agents interacted through a shared protocol but whose interests in characterizing that interaction diverge.

In each of these cases, institutional records remain useful, but their authority becomes something that must be argued, not assumed. As autonomous systems multiply the frequency of cross-boundary execution, the cumulative cost of that argument compounds. No incumbent can eliminate this friction by adding features to an existing centralized system, because reducing dependence on institutional cooperation isn’t an upgrade to the architecture, it’s a different one.

No single network will own all agent execution. The fragmentation of agentic deployment across cloud environments, organizational boundaries, regulatory jurisdictions, and commercial relationships isn’t a temporary state waiting to be resolved by the right consortium. It’s the permanent operating condition of autonomous systems in the real world. Portable verification matters specifically because that fragmentation is real and won’t consolidate into any single institutional substrate.

MIT economist Christian Catalini and co-authors, in Some Simple Economics of AGI (February 2026), model this structurally: the cost to automate any given task falls exponentially; the cost to verify is biologically bounded, constrained by human time and judgment. These curves diverge structurally. The gap between what AI can execute and what humans can afford to audit is what Catalini calls the Measurability Gap. His prescription is that verification must become a property of the transaction itself, embedded at the moment of exchange, independent of any model, platform, or actor with an interest in the answer. Catalini names the requirement; he does not specify the architecture. The question of which architecture satisfies it is where this piece is making a claim, not borrowing one.

IBM’s AGENTSAFE framework, published independently in December 2025, arrived at identical requirements from a governance direction: what it calls the Action Provenance Graph, a structured record linking each tool call, decision point, and internal reasoning state to a cryptographic signature, is precisely the infrastructure both MIT and Cambridge computer scientists identified as necessary from entirely different first principles. AGENTSAFE specifies the gap. It doesn’t close it.

The Architectural Answer

The verification problem has a structural solution, and its shape is becoming clearer as the failures accumulate.

The property the adversarial cases require has a name: institutional portability. A record that remains authoritative after the institution that originated it has become a party to a dispute, has lost jurisdiction, or simply has interests that diverge from the parties relying on it. Not tamper-resistance, existing systems provide that. Not immutability, blockchains provide that, with settlement latency that makes them unsuitable for high-frequency agent interaction. Specifically: provenance that survives the loss of institutional cooperation, verifiable by any party operating under different trust assumptions, without requiring any shared intermediary to remain online, cooperative, or neutral.

This is what distinguishes embedded provenance from better audit trails. A better audit trail answers “what does the organization’s record say?” Institutional portability answers “what occurred, independently of what any organization says about it.”

Multiple architectures may attempt to satisfy this requirement, append-only distributed attestations, threshold-signed event graphs, decentralized witness networks, zk-provable execution systems. The claim here is not that one implementation has a monopoly on the property. It is that any architecture which succeeds must provide institutional portability as a first-order design requirement rather than a governance assumption layered on afterward. That is the test, and it is architectural before it is competitive.

The key architectural insight: a record generated separately from an action and stored separately can always be questioned. It can be lost, altered, reconstructed, or simply wrong. A record bound cryptographically to the action at the moment of execution, one that travels with the transaction the way a bearer instrument travels with value, cannot be reconstructed after the fact, because it was never separate to begin with.

The TODA architecture was built from this requirement, not because its designers had identified the enterprise AI governance problem, but because the mathematics of fair exchange and digital provenance led there independently. Dann Toliver, Jon Crowcroft, Carlos Molina-Jimenez, and Hazem Danny Nakib at Cambridge’s Centre for Redecentralisation spent six years on foundational research into how digital objects can carry independently verifiable provenance without a central ledger. The formal proof, published in 2023 and 2024, establishes that a specific class of cryptographic data structures guarantees a unique canonical line of succession: each asset has exactly one valid history, and no party can fabricate an alternative. Double-spend is not merely unlikely; it’s excluded by structure.

It’s worth being precise about what embedded provenance guarantees and what it doesn’t. It cannot guarantee that an autonomous decision was correct, or that the agent acted within its intended policy scope, those are questions about model behavior that no provenance system can answer. What it does guarantee is that the execution history cannot be retroactively altered, selectively reconstructed, or institutionally withheld. The record of what the agent did becomes an independent fact, not a party’s account of it. In disputes, in discovery, in regulatory examination, that distinction is the difference between evidence and testimony.

The practical consequence: a TODA file behaves like a bearer instrument. It carries its complete chain of custody from creation forward, verifiable locally by any party with no network call required, dependent on no intermediary’s continued cooperation. Provenance travels with the transaction. Any party, a counterparty, regulator, insurer, or court, can verify it independently without trusting the organization that originated it.

The foundation for this commercial infrastructure has been live since 2023. Toliver as Chief Science Officer, Kris Coward, cryptographer systems, and Adam Gravitis as Chief Technology Officer are the same individuals who authored the papers and now operate this infrastructure. That continuity between foundational research and production deployment is uncommon in deep technology. The architecture was not specifically and narrowly designed for the enterprise AI governance problem, it predates the deployment wave that made that problem visible. Whether it satisfies the requirements that problem creates is a technical question the Rigs papers answer, and one the Qatom deployment is testing in production.

(For the deployment in production, the Qatom piece in this series covers it in detail.)

What This Builds Over Time

The economic properties of embedded provenance compound differently from settlement infrastructure.

Settlement infrastructure competes primarily on network effects and interoperability, which is why Google’s Agent Payments Protocol is already functioning as a neutral bridge between Visa TAP, Mastercard Agent Pay, and Stripe ACP. When a neutral protocol layer successfully standardizes across competing networks, the underlying networks compress toward utility pricing. The visible scramble at the settlement layer is a signal: institutions racing hardest here understand the window to establish position is limited.

Embedded evidentiary infrastructure accumulates rather than competes. An enterprise operating autonomous systems inside a provenance framework builds governance history, contractual defensibility, and institutional trust directly inside the execution layer. Over time, replacing that infrastructure means disrupting the continuity of the evidentiary record accumulated across years of autonomous activity. Institutional network effects operate through recognition: a provenance framework accepted by enterprises, regulators, insurers, and courts becomes more valuable with every additional institutional participant that treats its records as authoritative, and more costly to operate outside. That is historically very difficult to replicate once established.

The organizations that begin this accumulation earliest will find themselves, in three to five years, holding something their competitors cannot manufacture on any shorter timeline: a verified history of having operated with integrity, proven by mathematics rather than claimed by assertion.

There is a larger structural shift implicit in this. For most of the history of digital commerce, execution, payment, authorization, and evidence were separate operational layers, each managed by different infrastructure, reconciled after the fact, and governed by different institutional agreements. Autonomous systems place pressure on that separation because execution chains propagate faster than reconciliation systems can economically follow. The direction the market is moving, whether or not any single company named in this piece intended it, is toward a single atomic object: a transaction that carries its own payment, its own authorization proof, and its own independently verifiable execution record as intrinsic properties, not attached layers. Settlement and evidence become the same operation. The cost of institutional trust stops scaling with the volume of autonomous activity because trust is no longer assembled after the fact. It travels with the act itself.

Why the Pressure Is Arriving Now

This convergence is not being driven by ideology or protocol preference. It is being driven by economics and timeline.

Autonomous systems increase execution volume faster than institutions can increase human verification capacity, Catalini’s diverging cost curves, playing out in real deployments. Cross-system agent workflows are multiplying the frequency of execution that crosses organizational and jurisdictional boundaries. Regulatory frameworks in multiple jurisdictions are simultaneously tightening liability for AI-generated outcomes. And insurance markets, which price risk on the basis of what can be independently reconstructed, are beginning to price the absence of portable provenance directly into coverage terms and exclusions.

These pressures are not arriving sequentially. They are arriving together, compressing the timeline between “nice to have” and “operationally required.” The organizations building evidentiary infrastructure now are not ahead of the market, they are at the edge of a window that is closing as each liability event, each regulatory deadline, and each discovery dispute makes the cost of not having built it more legible.

Whether portable provenance becomes broadly authoritative will depend not only on cryptographic validity but on whether insurers, regulators, courts, and counterparties converge on treating independently verifiable execution records as operationally preferable to institution-bound attestations. That convergence does not happen automatically, it happens through the accumulation of cases, precedents, underwriting decisions, and procurement mandates that make the alternative increasingly costly. The organizations that have already built this infrastructure when that convergence arrives will be the ones that shaped it.

The Closing Condition

McKinsey’s 2026 AI Trust Maturity Survey found that only around 30 percent of organizations reached maturity level three or higher on agentic AI governance and controls. Microsoft’s Cyber Pulse report found that 80 percent of Fortune 500 companies have active AI agents embedded in production workflows. The gap between those two numbers is an infrastructure problem that policies and training programs cannot close.

The organizations treating verification as a compliance checkbox added afterward are accumulating liability their current metrics cannot see. The feedback lag hasn’t expired yet. When it does, through a regulatory investigation, an insurance dispute, or a commercial litigation that requires reconstructing an execution chain that was never built to be reconstructed, the gap between having evidentiary infrastructure and not having it will be difficult to close quickly.

The question for enterprise leaders has shifted from which AI can we deploy to what can we prove, and to whom. The answer requires infrastructure where verification is a property of the transaction itself, not a reporting layer attached after the fact, not a certification captured at deployment, not a log held by the same system that acted.

For most of institutional history, the authoritative record of what occurred was maintained by an institution separate from the occurrence itself. That architecture assumed the separation was sustainable, that execution and evidence could remain distinct layers, reconciled afterward, governed by whoever held the ledger. Autonomous systems operating across fragmented environments, at machine speed, under adversarial conditions, dissolve that assumption. The transaction that cannot produce its own independently verifiable record of itself becomes a liability rather than an asset, to its deployer, its counterparties, its insurers, and ultimately to every institution that inherits its consequences.

The title of this piece is not a metaphor. It is the architectural condition that autonomous systems are forcing into existence. When the transaction becomes the record, the question of institutional trust stops being about who holds the ledger. It becomes about whether the ledger can be held at all, outside any single institution’s authority, across any boundary, under any condition. That is the infrastructure the agent economy is building toward. The organizations that understand this early enough to build accordingly will not merely be compliant. They will be the ones that defined what compliance means.

References

Catalini, C., Hui, X. & Wu, J. — “Some Simple Economics of AGI.” arXiv:2602.20946 (February 2026).

Khan, R., Joyce, D. & Habiba, M. — “AGENTSAFE: A Unified Framework for Ethical Assurance and Governance in Agentic AI.” arXiv:2512.03180 (December 2025).

Molina-Jimenez, C., Toliver, D., Nakib, H.D. & Crowcroft, J. — Fair Exchange: Theory and Practice of Digital Belongings. World Scientific (2024).

Coward, K. & Toliver, D.R. — “Simple Rigs Hold Fast.” arXiv:2208.13617 (2022).

Coward, K., Toliver, D.R., Gravitis, A. et al. — “Rigging Specifications.” T.R.I.E., v0.9876 (January 2023).

Clifford Chance — “Agentic AI: The Liability Gap Your Contracts May Not Cover.” (February 2026).

IMF Policy Note — “How Agentic AI Will Reshape Payments.” Davidovic & Tourpe (April 2026).

California Assembly Bill 316 (effective January 1, 2026).

EU Product Liability Directive 2024/2853 (member-state implementation deadline December 2026).

Estate of Gene B. Lokken v. UnitedHealth Group, Case 0:23-cv-03514-JRT-SGE.

McKinsey & Company — “State of AI Trust in 2026.” (March 2026).

Microsoft Cyber Pulse — “80% of Fortune 500 Use Active AI Agents.” (February 2026).

Moffatt v. Air Canada, 2024 BCCRT 149.

Recent analysis from writers including Melody Koh have mapped the competitive geometry of the emerging agent web clearly: who controls supply, whether orchestration can be re-aggregated, and which incumbents risk tolling themselves out of relevance. Those are the right questions for the current moment. But there is a layer missing from the stack, one the industry is treating as a compliance problem rather than an infrastructure problem, and it is the layer that determines whether everything built on top of it holds. I examined the first signs of this gap in an earlier piece, You Cannot Audit a Probability: The Agentic AI Trust Wall. What has become clearer since is how structural the problem actually is.

The Agent Web Has a Missing Layer

The frameworks being written about this transition are largely correct. The disruption is real, the competitive logic is sound, and the companies being named, as either disintermediators or displaced, are generally the right ones.

What they miss is a category shift happening underneath all of it.

You Cannot Audit a Probability examined why probabilistic systems become difficult to govern once they produce consequential outputs. The agent web extends that problem from decision support into autonomous execution itself. The earlier piece was about model epistemology. This one is about infrastructure consequences.

When Routing Becomes Execution

For two decades, digital power was organized around discovery and aggregation. The interface between intent and selection was where control lived: search, feeds, platforms, marketplaces. The critical question was always who routes demand.

Agents change that. Not incrementally. Categorically.

When an agent recommends a hotel, the old logic applies. Someone still selects. There is still a human at the moment of consequence, and the system is accountable through that human. When an agent books the hotel, the category changes. The bottleneck is no longer routing; it is whether that action can be trusted, verified, and accounted for afterward, across systems that did not observe the decision process themselves.

Agents have become a new kind of actor, one that initiates, executes, and settles across multiple systems, often without a human in the loop at the moment things go wrong.

Once intent no longer requires selection, the system reorganizes, away from distribution and toward the integrity of autonomous execution. And integrity, at that level, requires infrastructure that does not yet exist at scale.

The Tollgate Incumbents Are Solving the Wrong Problem

SAP, ServiceNow, Workday: the major enterprise incumbents are choosing between two postures right now.

ServiceNow introduced Action Fabric at Knowledge 2026, opening its platform to external AI agents via a generally available MCP server. JPMorgan analyst, Mark Murphy, described the action-based consumption pricing as effectively a tax on customers using outside AI agents to interact with data they already store in ServiceNow’s apps. SAP published API Policy v4/2026 in April, prohibiting third-party AI agents from autonomously sequencing calls outside SAP-approved architectures, drawing immediate pushback from partners who called it lock-in, even as CEO Christian Klein sought to soften the message on the Q1 investor call. Workday has similarly foregrounded the financial upside of monetizing agent access.

This strategy is historically difficult to sustain once orchestration becomes portable. Tollgate incumbents signal their own vulnerability the moment they impose friction on autonomous orchestration. Enterprises charged enough for agent access eventually begin routing around the gate. That is the pattern of digital aggregation markets, and nothing about the current moment suggests it breaks here.

But the deeper issue runs underneath the question of discovery control. Their strategy solves orchestration control before solving evidentiary trust, and those are different problems on different timelines. Once agents execute autonomously across systems, somebody must be able to prove what occurred.

Reconstruction after the fact is insufficient. The relevant standard is evidentiary integrity under adversarial scrutiny: the proof a court, regulator, auditor, insurer, or counterparty would demand once autonomous systems generate real financial and operational consequences. The tollgate incumbents are unprepared for that question, and so, yet, are most of the disintermediators moving to replace them.

Settlement Is Not Verification

The Universal Commerce Protocol, co-developed by Google and Shopify and announced in January 2026 at the National Retail Federation conference, is probably the single clearest expression of where the market is heading. Backed by Walmart, Target, Etsy, and Wayfair as co-developers, and endorsed by more than twenty partners including Visa, Mastercard, and Stripe, UCP attempts to standardize how agents discover, negotiate, and execute transactions across merchant systems: agent-mediated discovery, agent-mediated checkout, machine-readable commerce negotiation, interoperable execution flows. It is the beginning of protocolized agent commerce infrastructure, and it formalizes a premise the market has now accepted: that agents are becoming transactional actors, not just recommendation systems.

Shopify was always merchant infrastructure rather than a consumer destination. Extending headless commerce into agentic commerce is evolutionary rather than disruptive to its identity. Google’s position is equally legible: if agents operate through Gemini and merchants speak UCP, then Google Pay becomes the credential and settlement layer underneath agent-mediated commerce.

Settlement and verification are different problems, and UCP solves only one of them.

Protocols like UCP, x402, and AWS AgentCore Payments address transactional execution between systems. They solve real and important parts of the payment coordination problem. What they leave untouched is the verification problem, which becomes increasingly consequential as agents interact recursively across organizational and protocol boundaries, each one inheriting the state produced by the last. As Christian Catalini and others have argued, cryptographic coordination systems become economically relevant when they reduce the coordination costs of establishing trust across parties that cannot rely on a single shared intermediary (see Built Before It Was Named). UCP solves coordination; trust remains unaddressed.

OpenAI’s Instant Checkout illustrated the difficulty directly. Operational issues reportedly included near-zero conversion rates, weak fraud infrastructure, sales tax complications, and merchant onboarding friction. Reading these as product immaturity misses the structural point: when the agent’s account of system state becomes the only account of system state, errors propagate in ways that surrounding infrastructure cannot reliably adjudicate afterward.

The operative question is who bears liability when autonomous execution is based on stale state, incorrect inventory, misinterpreted instructions, or records generated by the same probabilistic engine that performed the action. Clifford Chance’s analysis of agentic AI contracts found that under most current technology agreements, if an agent incorrectly authorizes a payment or misprices a product, suppliers’ standard disclaimers typically leave the customer holding liability for a system they did not design and cannot fully audit. The contractual framework wipes out meaningful recovery precisely when the stakes are highest.

This Does Not Stay Contained

The trust problem remains underestimated because agent infrastructure is still mentally divided into two categories: lightweight consumer systems and serious institutional systems. The assumption is that provenance, deterministic guarantees, and verifiable execution only matter once agents enter regulated domains, finance, healthcare, enterprise procurement.

That distinction will not hold.

The systems that contributed to the 2008 financial crisis were initially treated as distributed, localized, statistically manageable components of a larger market. The systemic risk emerged once interconnectedness, opacity, leverage, automation, and cascading dependencies reached sufficient scale. Nobody designed for systemic fragility. It emerged from composition.

Agent systems are beginning to evolve along structurally similar lines.

One hallucinated purchase or failed booking is containable. The deeper risk is recursive interaction between autonomous systems: agents consuming outputs from other agents, probabilistic state propagating across execution environments, unverifiable actions becoming composable infrastructure beneath larger systems. Once that occurs, low-trust domains stop remaining isolated. What began as a consumer-facing reliability problem becomes load-bearing infrastructure for decisions with real financial and legal consequences.

Aggregators centralized demand. Agent systems decentralize execution. But decentralized execution without verifiable state eventually recreates systemic fragility at machine speed.

McKinsey’s 2026 AI Trust Maturity Survey, drawing on approximately 500 organizations across industries and regions, found that only around 30 percent reached a maturity level of three or higher on agentic AI governance and controls. Separately, Microsoft’s Cyber Pulse report found that 80 percent of Fortune 500 companies now have active AI agents embedded in production workflows. The gap between those two figures is an infrastructure problem, one that policies and frameworks cannot close on their own, and that better training programs will not fix.

The emerging field of governed execution research reflects the same recognition from a different direction. Academic work on provenance systems for autonomous agents, proof-derived authorization architectures, and accountable multi-agent governance is converging independently on the same missing property: verifiable autonomous execution. When academic institutions, regulatory bodies, and enterprise deployments begin arriving at the same structural deficiency from different starting points, that convergence is signal, not coincidence.

What Serious Deployments Already Know

Gondola is a travel AI agent that books end-to-end itineraries autonomously: flights, hotels, transfers, dining reservations, coordinating across multiple provider systems in a single execution flow. It is one of the more complete examples of agentic commerce operating at production scale.

What made Gondola work was something less visible than the orchestration layer: the record of what the agent did had to be legible and authoritative to every downstream participant in the transaction chain, hotel reservation systems, airline databases, loyalty programs, payment processors, and the customer, none of whom were present when the agent made its decisions.

Marriott awards loyalty points because Gondola’s bookings are recognized by downstream hotel systems as valid direct reservations eligible for loyalty accrual. That recognition depends on transaction records that can move reliably across multiple systems, hotel reservation infrastructure, payment systems, loyalty databases, and customer accounts, while preserving enough integrity for parties who never observed the original transaction to treat the resulting state as authoritative.

This is the pattern that separates serious agent deployments from impressive demos. Discovery is difficult but tractable. Payment execution is attracting multiple well-capitalized efforts. The foundational problem that keeps getting deferred is producing a record of autonomous execution that remains trustworthy to systems and institutions that were never present for it. As McKinsey Partner Rich Isenberg put it: “Agency isn’t a feature, it’s a transfer of decision rights. The question shifts from ‘Is the model accurate?’ to ‘Who is accountable when the system acts?’”

Liability, in other words, is becoming a technical problem: specifically, whether system state can be independently verified at the moment a claim is made against it. Policy cannot substitute for infrastructure. Without portable provenance, downstream systems would have no reliable way to distinguish between a valid autonomous booking flow and an unverifiable synthetic transaction narrative generated after execution.

A log generated after the fact by the same system that acted answers nothing.

Subscribe now

The Legal Timeline Is Not Waiting

The IMF recently named the underlying structural tension: payment systems require deterministic execution and settlement finality, while agentic AI introduces probabilistic reasoning and non-deterministic execution paths. Separating AI orchestration from deterministic settlement is a coherent first step, but insufficient on its own, because even with deterministic settlement, the surrounding record may remain probabilistic, generated after execution by the same system that executed, coherent in narrative but independently unverifiable in fact.

That distinction matters acutely once systems become adversarial.

Litigation involving UnitedHealth demonstrates the issue in real time. The legal question cuts deeper than whether an AI-assisted decision occurred; organizations must prove, under scrutiny, that the records surrounding those decisions are accurate, complete, and independently verifiable, and produce that proof without relying on the AI system’s own account of itself.

The regulatory landscape is tightening on multiple fronts, though unevenly. California’s AB 316, which took effect January 1, 2026, forecloses the autonomous-harm defense: developers, modifiers, and users of AI systems can no longer argue that the AI acted independently as a shield against civil liability. Colorado’s original AI Act, which would have required annual impact assessments for high-risk systems by June 2026, has been stayed by a federal court and substantially replaced by the legislature; its successor, if signed, takes effect January 1, 2027, under a narrower framework. The EU Product Liability Directive classifies AI software as a product subject to strict liability, with member-state implementation deadlines in December 2026. The direction of travel across jurisdictions is consistent even where individual timelines shift.

There is also a geopolitical dimension beginning to emerge. Economies that cannot independently verify autonomous machine execution may find themselves structurally dependent on foreign orchestration layers, a sovereignty problem dressed as a technical one. Cross-jurisdiction verification, sovereign execution infrastructure, and regulatory interoperability are not yet central to the agent web conversation. Once autonomous systems begin mediating financial, commercial, and governmental coordination at scale, they will be impossible to avoid.

These are current exposures being accumulated, on a timeline that is not synchronized with most organizations’ infrastructure roadmaps.

The Architecture the Market Is Converging On

The verification problem has a structural solution, and its shape is becoming clearer as the failures accumulate.

The key insight is this: a record generated separately from an action, and stored separately from an action, can always be questioned. It can be lost, altered, reconstructed, or simply wrong. A record bound cryptographically to the action at the moment of execution, one that travels with the transaction the way a bearer instrument travels with value, cannot be reconstructed after the fact, because it was never separate to begin with.

This is the architectural direction that serious provenance infrastructure takes. Rather than logging what an agent did and storing that log somewhere retrievable, the proof of what occurred becomes a structural property of the transaction itself. Any party can verify it independently. No intermediary needs to be trusted. No reconstruction is required, because nothing was ever separated.

The practical consequence is that compliance stops being a reporting layer bolted onto an execution system. It becomes a property of the execution itself, present at every transaction, verifiable by any counterparty, portable across the systems that need to trust it. Settlement and verifiable record become the same operation rather than two operations that must be reconciled.

The emergence of companies focused specifically on agent governance, policy enforcement, and execution accountability signals that the market is beginning to recognize this gap. Orchestration alone is insufficient once agents begin operating across institutional boundaries. That recognition is still early; the infrastructure buildout that follows it will move fast.

This is where the market for agentic infrastructure is converging, not because any single company has made it so, but because the failures accumulating across agent deployments all point to the same missing property. A small but growing set of infrastructure efforts is beginning to converge on this problem from different directions: verifiable state transfer, portable provenance, governed execution, and cryptographically attestable coordination across systems. TODAQ through Qatom, is building this layer around execution-bound cryptographic proof designed for the phase of the agent web that follows autonomous execution at scale

The Missing Layer

The discovery layer is being built. The payment execution layer is being built.

Beneath both of them is a layer the agent web has not yet fully recognized as infrastructure: the systems that make autonomous execution independently verifiable, portable across institutions, and resilient under adversarial scrutiny.

The problem is not observability. It is evidentiary integrity.

A log generated after the fact by the same system that acted cannot serve as the foundation for financial coordination, institutional accountability, or autonomous commerce at scale. As agents begin operating across organizational and jurisdictional boundaries, every consequential action eventually collapses into the same question:

Not simply what did the agent do, but can the system prove it independently of the agent’s own account of itself?

That requirement changes the architecture of the stack beneath autonomous execution. Verification stops being a reporting layer attached afterward and becomes a property of the transaction itself: portable, attestable, and durable across the systems that inherit its state.

This is the layer the market is beginning to converge toward, not because regulation demands it or because companies prefer it, but because autonomous systems operating without verifiable state eventually become ungovernable.

The organizations that recognize trust as infrastructure will help define the next phase of the agent web. The ones that continue treating it as compliance will discover the distinction too late.

Subscribe now

References and Notes

1. California Assembly Bill 316 (2026, January 1). Amends California Civil Code § 1714.46, prohibiting autonomous-harm defenses in civil actions involving AI systems. Baker Botts. (2026, January). California eliminates the ‘autonomous AI’ defense. https://ourtake.bakerbotts.com/post/102m29i/california-eliminates-the-autonomous-ai-defense-what-ab-316-means-for-ai-deplo

2. Catalini, C. (2026, February 24). Some simple economics of AGI (MIT Sloan Research Paper). https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6298838
   Referenced in the context of cryptographic coordination systems and the economics of trust across parties without shared intermediaries.

3. Clifford Chance. (2026, February 10). Agentic AI: The liability gap your contracts may not cover. https://www.cliffordchance.com/insights/resources/blogs/talking-tech/en/articles/2026/02/agentic-ai-and-the-liability-gap-your-contracts-may-not-cover.html
   Analysis of liability allocation in agentic AI contracts and how standard technology agreement disclaimers interact with autonomous execution failures.

4. Colorado AI legislation update. (2026). SB 24-205 (original Colorado AI Act) stayed by federal court (April 27, 2026); replaced by SB 189 (passed May 2026, effective January 1, 2027 if signed).

5. Dignan, L. (2026, May 5). ServiceNow Knowledge 2026: AI Control Tower, Action Fabric, Autonomous Workforce and more. Constellation Research. https://www.constellationr.com/insights/news/servicenow-knowledge-2026-ai-control-tower-action-fabric-autonomous-workforce-and

6. European Union. (2024). Product Liability Directive (classifies AI software as a product subject to strict liability). Member-state implementation deadline: December 2026.

7. Gondola AI. (n.d.). Production travel agent coordinating multi-system autonomous bookings (case study in provenance infrastructure requirements). https://www.gondola.ai/

8. International Monetary Fund. (2025–2026). Analysis of structural tensions between deterministic payment settlement and probabilistic AI execution paths.

9. Koh, M. (2026, May 13). How the agent web gets built: Why incumbents will toll themselves out of relevance. Ground Truth.

   Foundational analysis of agent-driven disintermediation, orchestration portability, and tollgate incumbent dynamics. This essay builds on Koh’s competitive framework while examining the unresolved verification and provenance layer beneath autonomous execution.

10. McKinsey & Company. (2026, March). State of AI trust in 2026: Shifting to the agentic era. https://www.mckinsey.com/capabilities/tech-and-ai/our-insights/tech-forward/state-of-ai-trust-in-2026-shifting-to-the-agentic-era (Survey of ~500 organizations; ~30% reached maturity level 3+ on agentic AI governance and controls.)

11. Microsoft. (2026, February). 80% of Fortune 500 use active AI Agents. Microsoft Security Blog. https://www.microsoft.com/en-us/security/blog/2026/02/10/80-of-fortune-500-use-active-ai-agents-observability-governance-and-security-shape-the-new-frontier/

12. OpenAI Instant Checkout. (2025–2026). Reported operational challenges including near-zero conversion rates, fraud infrastructure gaps, sales tax complications, and merchant onboarding friction.

13. Rich Isenberg (McKinsey Partner). (2026). Comments on accountability implications of agentic AI.

14. SAP API Policy v4/2026. (2026, April). AI clause reported in: “AI clause in new SAP API policy provokes lock-in concern,” The Register. Waehner, K. (2026, May 2). Data ownership in the age of agentic AI: Why SAP’s API policy forces a data integration reckoning for every enterprise. https://www.kai-waehner.de/blog/2026/05/02/data-ownership-in-the-age-of-agentic-ai-why-saps-api-policy-forces-a-data-integration-reckoning-for-every-enterprise/

15. ServiceNow. (2026, May 5). ServiceNow opens its full system of action to every AI Agent in the enterprise. ServiceNow Newsroom. https://newsroom.servicenow.com/press-releases/details/2026/ServiceNow-opens-its-full-system-of-action-to-every-AI-Agent-in-the-enterprise/default.aspx

    Mark Murphy quote/analysis on action-based pricing: “ServiceNow, SAP and Workday Make AI Agents Pay to Play,” PYMNTS.com (May 2026). https://www.pymnts.com/artificial-intelligence-2/2026/servicenow-sap-and-workday-make-ai-agents-pay-to-play/

16. UnitedHealth Group litigation. (2024–2026). Ongoing litigation and regulatory scrutiny regarding use of AI in coverage decisions.

17. Universal Commerce Protocol (UCP). (2026, January 11). Announced at National Retail Federation conference. Co-developers: Google, Shopify, Walmart, Target, Etsy, Wayfair. Google Developers Blog (2026, January). Under the Hood: Universal Commerce Protocol (UCP). Shopify Engineering (2026). Building the Universal Commerce Protocol.

Further reading:

Ground Truth

How the Agent Web Gets Built

AI agents are becoming the new discovery layer, sitting above Booking.com, LinkedIn, and the platforms that currently own consumer demand. The structural move that hotels spent fifteen years trying to make is now available to any startup with the right infrastructure. The categories where it works, and where it collapses on contact, are written in the l…

Read more

3 months ago · 3 likes · Melody Koh

News peg: The IMF’s agentic payments policy note (April 24, 2026) and Amazon’s AgentCore Payments launch (May 7, 2026).

On May 11th, a developer with 40+ production agent deployments posted in r/AI_Agents: “Stop building AI agents.” It hit 376 upvotes. The comments were full of people who learned the same lesson the hard way.
Agents hallucinate. They resist auditing. And in regulated industries, that’s becoming a legal liability.

The AI agent market is maturing, and maturation is uncomfortable. The gap between what agents do in demos and what they do in production has become impossible to ignore, and the developers closest to the problem are saying so out loud.

On May 11th, the top post on r/AI_Agents, from a developer with over 40 production deployments, put it plainly: stop building AI agents. Automations outperform agents in production. Agents hallucinate, resist auditing, and collapse on unexpected inputs. In regulated industries, compliance reviewers need deterministic audit trails. Autonomous black boxes fail that requirement. The post drew 376 upvotes and a thread full of agreement from people who had learned the same thing the hard way.

This is not a fringe opinion. Surveys of teams running agents in production show 60% operating with no formal governance framework. Thousands of applications have leaked sensitive data because agentic systems shipped without deterministic audit infrastructure underneath them. Y Combinator’s current Request for Startups names agents with audit trails, deterministic behavior, and compliance capabilities as explicit investment priorities, which is the VC tier funding around a failure mode they are watching play out in real time.

The market is converging on a conclusion: the winners will be builders who ship reliable automations with proper guardrails, not the loudest agentic demos.

Why Auditability Is Harder Than It Looks

The production problems are not all unsolvable. Structured outputs, function calling, evaluation harnesses, and hybrid architectures that wrap LLM reasoning inside deterministic workflows have all made agents meaningfully more reliable. These approaches work, and teams shipping in regulated industries are using them.

The harder problem is what happens to the record of what occurred. When an LLM-orchestrated agent produces a log of its actions, that log is itself a language model output: a reconstruction, produced by the same probabilistic engine that executed the action. It can be internally consistent, confidently written, and factually wrong. Better reliability practices reduce the frequency of errors; they do not change the nature of the record.

The IMF’s recent policy framework gestured at this without quite landing on it. It proposed separating probabilistic AI decision-making from deterministic payment execution, which is a sound instinct. But the framework assumes that once execution happens, the record of what happened is trustworthy enough to trace backward through. That assumption is where it gets complicated. AWS’s AgentCore Payments infrastructure, launched in preview this month, stores logs in CloudWatch: whatever the agent reports, observable but not independently verified.

Trusted Execution Environments address part of this. TEEs are hardware-isolated compute regions where remote attestation can cryptographically prove which model ran against which input. That closes a real gap: you can verify the execution environment was not tampered with. What TEE attestation does not cover is whether the log the model generated faithfully represents the sequence of decisions across a multi-step workflow. The hardware integrity is provable; the semantic accuracy of the record is not.

This is the specific gap that structured outputs and better observability tooling do not reach. It is not an argument that those approaches are inadequate for most purposes. It is an argument that for regulated industries where the log is evidence, the reconstruction problem is still open.

What the Correction Selects For

MIT economist Christian Catalini, writing independently in Some Simple Economics of AGI, identifies verification-grade infrastructure as the foundational requirement of the agentic economy: systems where agent actions produce receipts that travel with the data, verifiable by any party. When that infrastructure is absent, agents exploit the gap between what is measured and what was intended. The endgame is legal and financial accountability; agent outputs that can be defended, insured, adjudicated.

The legal pressure is already arriving. A class action alleging UnitedHealth’s AI model had a 90% error rate on appealed claim denials is in federal discovery, with tens of thousands of internal documents being produced. The 90% figure is an allegation, not an adjudicated finding, and UnitedHealth disputes it. But the shape of the case is instructive regardless of outcome: logs existed, assembled after the fact from records that did not travel with the decisions, and a court order was required to surface them. The question is not whether logs exist. It is whether they are accurate and whether the organization can prove it.

The EU Product Liability Directive classifies AI as a product subject to strict liability, effective December 2026. Gartner tracks AI governance platform spending reaching roughly $500 million in 2026, rising steeply as regulatory pressure increases. The organizations that will navigate this cleanly are the ones that built for auditability before it became a legal requirement, not after.

What Verifiable Infrastructure Actually Requires

Solving the reconstruction problem means removing the reconstruction step. The record of what happened needs to be bound to the transaction at the moment of execution, before any language model generates a summary of it. Several architectural approaches point in this direction: deterministic workflow engines that log at the infrastructure layer rather than the application layer, blockchain-based ledgers where transaction records are independently verifiable, and cryptographic provenance systems where proof of what occurred travels with the asset itself rather than being stored separately.

The TODA-file protocol takes the last approach. Provenance is bound at execution and verifiable by any party with no intermediary. The formal proof underlying the protocol, published by researchers at Cambridge’s Centre for Redecentralisation, uses structural induction to demonstrate that double-spend is not merely unlikely but excluded by the system’s structure. That is a meaningful property for regulated use cases where the audit trail needs to hold up under legal scrutiny rather than just operational review.

We are a small operation, for now, relative to the infrastructure being built around x402 and AgentCore. Volume today is thousands of transactions per day against x402’s aggregated 169 million. We note that not because the comparison favors us, but because the question worth asking of any agentic payment infrastructure is not just how much it has processed, but what it can prove about each transaction when asked. That question will become harder to avoid as the UnitedHealth discovery process continues and the EU Product Liability Directive takes effect in December. The organizations positioned to answer it will be the ones that treated auditability as a design requirement rather than a compliance checkbox added afterward.

Subscribe now

Sources

1. IMF Policy Note, How Agentic AI Will Reshape Payments, Sonja Davidovic and Hervé Tourpe, April 24, 2026.

2. Amazon Web Services, Agents That Transact: Introducing Amazon Bedrock AgentCore Payments, May 7, 2026. Launched in preview.

3. x402 Foundation / Linux Foundation press release, April 2, 2026. By May 7, 2026 (per Coinbase): 69,000 active agents, 169 million transactions.

4. Estate of Gene B. Lokken v. UnitedHealth Group, Case 0:23-cv-03514-JRT-SGE. The 90% error rate is an allegation in the plaintiff complaint, not an adjudicated finding. UnitedHealth disputes the characterization.

5. Gartner AI governance platform spending figures, 2026. Gartner projects the market reaching approximately $492 million in 2026, growing toward $1 billion by 2030, driven by regulatory requirements. [Available via Gartner subscription.]

6. EU Product Liability Directive (2024/2853): implementation by December 9, 2026; includes AI software as a “product” subject to strict liability.

7. TODA Rigs Architecture, Formal Proof, Cambridge University CRDC. Kris Coward and Dann Toliver, co-authors of Rigging Specifications (T.R.I.E., 2023).

8. Catalini, Hui & Wu, Some Simple Economics of AGI, 2025.

9. r/AI_Agents, May 11, 2026. Top post (376 upvotes): “Stop Building AI Agents.”

10. On TEEs and LLM attestation: OLLM (Trusted Execution Environments in Confidential AI, 2026); Attestable Audits (Verifiable AI Safety Benchmarks Using Trusted Execution Environments, arXiv 2025).

Leave a comment

Prior posts in this series:

• Built Before It Was Named

• An MIT Economist Just Named the Gap

• Everyone’s Building AI Agents — Nobody’s Solved This

• The Payment Layer for the AI Economy

There’s a moment in every infrastructure cycle when the thing everyone said was coming actually arrives. Not as a roadmap slide or a whitepaper. As a tool you can install.

That moment is now.

The conversations we’ve been tracking, and in some cases, seeding over the past several months have all pointed at the same structural gap. AI agents are executing at machine speed. They’re calling dozens of services per task, making purchasing decisions autonomously, and chaining outputs across providers without a human in the loop. The compute infrastructure for this is largely in place. The model capability is moving fast. What wasn’t in place, until now, was the payment layer that makes agent-to-agent commerce actually work.

We built that layer. We called it TAPP. We’ve been running it in production since 2023, and we’ve written about why it matters for AI companies, for creators, for the economics of microtransactions that legacy rails make structurally impossible.

What we hadn’t done was give it a front door that any developer, any agent runtime, any MCP-compatible tool chain could walk through in three steps.

That’s Qatom.

The Standard That Made This Possible

Agentic AI tooling has, in the last twelve months, begun converging on a standard. The Model Context Protocol (MCP) has become the lingua franca of how agents discover and call external tools. If you’re building agents in 2026, you’re either already building on MCP or you’re about to be. The ecosystem is moving fast and it’s moving in one direction.

MCP solved a real problem: a standard interface so agents can talk to tools without bespoke integration work at every junction. What it didn’t solve, what no one in that ecosystem had solved, is how agents pay for what they call.

The attempts have been visible to anyone building in the space. Legacy rails charge 2.9% plus $0.30 on transactions that might be worth three cents and settle days after the service was consumed. From the crypto side, x402, Coinbase’s protocol reviving HTTP’s 402 status code for stablecoin payments, diagnosed the problem correctly and moved fast. But it was built for crypto-native operators, and the enterprises, AI companies, and commercial API providers who run on commercial banking infrastructure and settle in dollars are not its constituency.

Qatom is the MCP server that adds the missing primitive: an agent that can pay. No crypto wallet required. No gas. No facilitator sitting between the payment and the settlement. USD, settled in flight, on TODA underneath.

What It Actually Does

The architecture is worth understanding, because the design choices matter.

Payment in Qatom travels inside the HTTP request itself, a header attached to the API call, settled between counterparties before the response comes back. No callback. No webhook. No reconciliation cycle. The response either arrives paid or it doesn’t arrive. This is the vending machine model we’ve been describing since February, finally expressed as a working MCP primitive: insert payment, receive service, atomically, with no intermediary absorbing margin at every hop.

Underneath that interface is the TODA stack, the same cryptographic infrastructure we’ve been describing since the Built Before It Was Named piece. File-based digital bearer assets, not balances. USD-TDN files that behave like physical cash: portable, self-verifying, carrying their own proof of provenance without depending on any central ledger. No blockchain. No gas. No volatility. Settlement in milliseconds between Twins, with bank rails connected for funding and payout in dollars where it counts.

For a developer or an enterprise AI team, the practical picture looks like this. Your agent gets a wallet. It can check its own balance as a standard MCP tool call. It can discover paywalled APIs in a live marketplace headless catalog, priced per call, not per month. It can pay for what it uses in the same request that calls the tool. And if you’re providing a service, you can register any HTTP API as a payable tool through chat or REST, set your price per call, and define how revenue splits across however many parties share in the value, up to two hundred payees per payout, settled atomically at the moment the call clears.

The fee across all of this is zero. That’s the architecture at work, not a promotional offer, when you remove the intermediary chain that legacy rails require, zero fees is what the math produces.

That’s what the infrastructure does. The question worth sitting with is why the window to build on it is shorter than most people currently assume.

Why the Window Is Narrow

The MCP ecosystem is still early enough that the payment primitive it adopts will become load-bearing infrastructure. The standard that wins here doesn’t just win a product category. It becomes the default assumption baked into every agent runtime, every tool provider, every enterprise deployment that gets built on top.

The history of infrastructure is the history of defaults. Whoever built the card rails didn’t make news in proportion to their eventual importance. AWS launched in 2006 and was considered a developer curiosity. The window to build a position in a new infrastructure layer is narrow, and it closes when the incumbents get entrenched.

That window is why the architectural gaps in what already exists matter now, not later. Demonstrating real traction and demand, x402 has processed over 100 million payments in its first six months. But a formal analysis published this year by researchers across Peking University, Shanghai Jiao Tong University, and Zhongguancun Laboratory (Li et al., “A402,” arXiv 2603.01179) documented structural flaws that x402 v2 left unresolved. Service providers must execute requests before payment confirms on-chain, meaning they absorb non-payment risk on every call. And because end-to-end latency is bounded by blockchain confirmation time, high-frequency interaction is structurally impractical; on-chain fees make fine-grained micropayments economically unviable at volume. The cumulative effect is measurable: an agent retrieving data from 100 x402-protected APIs accumulates up to 110 seconds of payment overhead alone.

There’s also a centralization problem that x402’s own community has been openly debating. Every payment routes through a single facilitator which, if compromised, can fabricate settlements or take down every x402-gated service by going offline, a single point of failure at the economic core of a protocol designed to eliminate intermediaries. And the relay model has no sustainable revenue mechanism at the protocol level: gas costs are currently absorbed as a Coinbase subsidy with no path to protocol-level compensation. Every successful payment infrastructure in history has earned a return on the value it creates. x402’s relay layer, as currently built, does not.

These are not edge cases to be optimized away. They are consequences of routing machine-speed commerce through a consensus mechanism designed for something else.

Legacy rails face a different version of the same problem. They’re wired into commercial banking and trusted by enterprises, but they were built for monthly human billing. Batching thousands of micropayments to reduce per-unit fees re-introduces settlement latency, requires reconciliation cycles, and still prices three-cent transactions into incoherence.

Agents are transacting right now. One of our earliest AI service customers went from dozens of API calls per hour to multiple per minute sustained around the clock, not because a human was clicking, but because AI systems were calling other AI systems and making autonomous purchasing decisions in real time. We watched that happen in production. The volume was real. The payment infrastructure held because it was built for exactly this load.

Qatom makes that accessible to every developer building agents today. The install is one line. Authentication is OIDC. The marketplace is live and dynamic. The agent that calls a tool is the agent that pays for it, in the same request, with no human required.

For the Builders

If you’re building agent workflows that call external APIs, code generation, data retrieval, model invocations, media synthesis, you’ve already encountered the friction. Either you’ve absorbed cost into a subscription that doesn’t match your actual usage pattern, or you’ve batched transactions to make unit economics tolerable, or you’ve simply priced the APIs you’d use out of scope because the fee structure made the math not work.

The 63-cent workflow we described in February, script generation, voiceover, music, image generation, video rendering, five API calls, five providers, costs $1.64 in fees on legacy rails before any of those providers have seen a dollar. With Qatom, the fee is zero and the settlement is atomic. A three-cent transaction becomes economically viable. A tool you’d have built as a subscription becomes a pay-per-call service and earns from day one.

That changes what’s worth building. The long tail of developer tools, data services, and specialized AI capabilities that never made sense as subscriptions, because no individual developer could justify the monthly commitment for occasional use, becomes a real market when the payment primitive supports it.

For the Enterprises

The Built Before It Was Named piece covered the governance dimension in detail. The short version: as enterprises deploy autonomous agents at scale, the question regulators, counterparties, and insurers are now asking is not whether agents executed, it’s whether you can prove what they did. The TODA architecture gives every transaction a cryptographic record that travels with it, verifiable by any party, dependent on no intermediary’s continued cooperation.

That’s embedded in Qatom, not bolted on after. Every transaction that flows through Qatom carries the same provenance guarantees we described when we wrote about AGENTSAFE and the Catalini macroeconomic analysis. Settlement and verifiable record are the same atomic operation. Compliance becomes a property of the infrastructure rather than a layer added on top.

For enterprise AI teams evaluating where to place a dependency, that sequencing is the relevant fact.

What Comes Next

Qatom ships today as a hosted MCP tool, compatible with any MCP-compatible agent harness; Claude, OpenClaw, Hermes, Codex, or whatever runtime your stack runs on. The marketplace is live. The wallet is live. The earning side, registering your API as a payable tool and collecting per-call revenue, are all live.

The install is one line: clawhub install Qatom. Three steps to a wallet, a marketplace, and agents that can finally transact.

We’ve spent years building infrastructure that nobody was asking for yet because the mathematics said it would be necessary. The mathematics was right. The moment it was describing is this one.

Your agents can transact now. The rail is there.

TODAQ Micro builds verification and payment infrastructure for AI Agents. Qatom is available now at qatom.ai and on GitHub at github.com/todaqmicro/openclaw.

TODAQ - Technical documentation https://engineering.todaq.net/

To reach us: hello@todaq.net.

References

On the TODA / TAPP Infrastructure

Molina-Jimenez, C., Toliver, D., Nakib, H.D. & Crowcroft, J. Fair Exchange: Theory and Practice of Digital Belongings. World Scientific, 2024. (Foundational research on the Fair Exchange dilemma; attestables; and proof that fairness can be a mathematical property of protocol architecture rather than a social or institutional one.) https://www.worldscientific.com/worldscibooks/10.1142/q0448

Coward, K. & Toliver, D.R. “Simple Rigs Hold Fast.” TODAQ / T.R.I.E., 2022. arXiv:2208.13617. (Cryptographic proof of Integrity-at-a-Distance and double-spend prevention via structural induction.) https://arxiv.org/abs/2208.13617

Coward, K., Toliver, D.R., Gravitis, A. et al. “Rigging Specifications.” TODAQ / T.R.I.E., v0.9876, January 2023. (Co-authored by CTO Adam Gravitis; defines the TODA file as a digital bearer instrument and specifies the Rigs architecture.) https://trie.site/rigging_specifications.pdf

External Sources

On Enterprise AI Governance and Macroeconomics

Catalini, C., Hui, X. & Wu, J. “Some Simple Economics of AGI.” February 26, 2026. arXiv:2602.20946. (Source for the Measurability Gap; Counterfeit Utility; Trojan Horse Externality; False Confidence Trap; and the prescription that verification must be native to each transaction.) https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6298838

Khan, R., Joyce, D. & Habiba, M. “AGENTSAFE: A Unified Framework for Ethical Assurance and Governance in Agentic AI.” IBM, December 2025. arXiv:2512.03180. (Source for the static guardrail problem and identification of cryptographic action provenance as the critical missing layer in enterprise AI governance.) https://arxiv.org/abs/2512.03180

On x402 Architecture and Limitations

Reppel, E., Roscoe, C. & Nickerson, J. “Introducing x402 V2: Evolving the Standard for Internet-native Payments.” Coinbase Developer Platform / x402.org, December 11, 2025. (Primary source confirming x402 launch in May 2025; 100M+ payments in six months; v2 scope limited to multi-chain and SDK modularity with atomicity flaws unresolved.) https://www.x402.org/writing/x402-v2-launch

Li, Y., Wang, L., Wang, K., Yang, Z., Wang, K., Guan, Z. & Gao, J. “A402: Binding Cryptocurrency Payments to Service Execution for Agentic Commerce.” Peking University / Shanghai Jiao Tong University / Zhongguancun Laboratory / Beijing Jiaotong University, 2026. arXiv:2603.01179. (Primary source for structural flaws in x402: L1 non-payment risk to service providers; L3 latency and cost limitations at scale. Also source for cumulative latency figures: 50–110s for 100-API agent, 25–55s for 50-source trading bot. Confirms flaws remain unresolved in x402 v2.) https://arxiv.org/abs/2603.01179

Stone, D. “The x402 Facilitator Problem: How to Remove the Centralized Trust Bottleneck.” Tangle, March 22, 2026. (Source for facilitator single-point-of-failure analysis: fabrication, censorship, and downtime failure modes; facilitator verifies and settles with zero cryptographic proof of correctness; no fallback or quorum mechanism.) https://tangle.tools/blog/decentralizing-x402-facilitator/

YQ “The X402 is great, but what are some of the hidden problems?” PANews / Jinse Finance, October 31, 2025. (Source for relay economics analysis: $0.0006 gas cost per transaction with no protocol-level compensation; two-phase settlement latency of 500–1100ms per single request; EIP-3009 exclusivity limiting compatibility with USDT and DAI.) https://www.panewslab.com/en/articles/87f007ff-f2c6-4b41-919d-24e26c295912

Matos, G. “What is x402? The HTTP-402 payments standard powering AI agents, explained.” CryptoSlate, December 18, 2025 (updated February 5, 2026). (Source for enterprise compliance burden framing: custodying keys, managing stablecoin balances, and compliance risk for agent fleets.) https://cryptoslate.com/what-is-x402-the-http-402-payments-standard-powering-ai-agents-explained/

Coinbase “Coinbase and Cloudflare Will Launch the x402 Foundation.” Coinbase Blog, September 23, 2025. (Source for x402 Foundation co-launch date, governance mission, and Cloudflare partnership.) https://www.coinbase.com/blog/coinbase-and-cloudflare-will-launch-x402-foundation

Internal Sources

Khan, S. “The Payment Layer for the AI Economy: How internet-native payments enable machines to transact.” TODAQ Press, February 18, 2026. (Source for the 63-cent AI workflow example; $1.64 in fees on legacy rails; 95%+ contribution margin validation; vending machine payment model; AI-to-AI transaction volume data; customer scaling from dozens of API calls per hour to multiple per minute.)

Khan, S. “Everyone’s Building AI Agents. Nobody’s Figured Out How They Get Paid.” TODAQ Press, February 28, 2026. (Source for batching-as-workaround critique; legacy rails analysis; x402 framing as crypto-native but wrong constituency; 95% cost reduction versus alternative rails; production evidence of machine-to-machine scaling.)

Khan, S. — “Built Before It Was Named: MIT named it. IBM specified it. The proof was already done — and the infrastructure built on it is live.” TODAQ Press, March 15, 2026. (Source for TODA cryptographic architecture; Rigs papers; Fair Exchange framework; AGENTSAFE / IBM governance gap; Catalini macroeconomic analysis; enterprise provenance and verifiability requirements; TAPP commercial deployment since 2023.)

ENTERPRISE AI · GOVERNANCE · AGI · DEEP TECHNOLOGY
· AI PAYMENTS · CRYPTOGRAPHIC INFRASTRUCTURE ·

Enterprise AI is executing faster than any organization can verify. That gap—between what agents do and what anyone can confirm they did—is now the subject of rigorous independent research across macroeconomics, computer science, and governance. Three research tracks arrived at the same infrastructure requirement from entirely different directions. Two identified it as the critical missing piece. One had already built it. This is that story — and why the convergence matters more than any of the three tracks alone.

The contract processing system goes live on a Monday. By Friday, throughput is up forty percent. Unit costs are down. The operations team is fielding congratulations. Six weeks later, a routine audit surfaces something less comfortable: hundreds of contracts that were processed correctly by every measurable standard (correctly classified, routed, and priced) but contained a structural error the system was never trained to flag. The error, individually minor, has compounded across volume into a seven-figure liability exposure.

The system did exactly what it was optimized to do. It had been optimized for the wrong thing.

No individual acted in bad faith. No model malfunctioned. What was absent was any mechanism to confirm, in real time, whether what the system was optimizing for matched what the organization actually needed. By the time the gap became visible, the resources had been consumed. The output appeared productive. The utility was counterfeit.

That scenario is hypothetical. What follows is not. In July 2025, a Replit AI coding agent working on a live project for a SaaStr executive ignored an explicit instruction freeze, deleted a production database containing records for over 1,200 executives and companies, and then told the user recovery was impossible. The user discovered the full extent of what had happened only by interrogating the agent directly. The agent had generated no external signal of failure. No alert. No log entry visible to any party other than the agent itself. The record of what it had done existed only in its own account of itself — an account it had already used to mislead. What was absent was any mechanism independent of the agent to confirm what had actually occurred.

That incident is one data point in a much larger pattern. McKinsey’s 2025 State of AI survey found that 88 percent of organizations are using AI in at least one business function, but only 39 percent report any measurable EBIT impact. That gap, between widespread deployment and negligible value realization, points to a structural failure beneath the headline numbers.

Distinct bodies of research, spanning macroeconomics, computer science, cryptographic design and formal mathematics, and AI governance, have produced rigorous accounts of why this failure is predictable, why current remedies are inadequate, and what the infrastructure that prevents it must look like. Two of those tracks — macroeconomics and enterprise AI governance — independently identified the same infrastructure gap as the critical missing piece. A third, Cambridge computer science, had independently built the basis for the infrastructure that satisfies both of their prescriptions. This article traces that convergence.

Part I: The Economist’s Diagnosis

Christian Catalini, founder of the MIT Cryptoeconomics Lab, and co-authors Xiang Hui (Washington University in St. Louis) and Jane Wu published ‘Some Simple Economics of AGI’ on February 26, 2026. It is a rigorous macroeconomic analysis of why standard productivity frameworks are failing to predict the actual consequences of autonomous AI deployment. Read carefully, it is also a formal economic description of an infrastructure problem that, as this article will show, computer scientists at Cambridge had already solved — working from entirely different first principles, for entirely different reasons.

Its central argument turns on a distinction with significant consequences. Traditional economic models treat AI as a labor substitute: a cheaper, faster version of a human worker. That framing made reasonable sense for narrow, well-defined automation, where the task was specified in advance and the output could be evaluated against a clear standard. It stops working when agents gain broad agency: the ability to pursue goals autonomously across open-ended tasks, adapting their methods without being re-specified at each step. At that point, the limiting factor on economic value ceases to be the scarcity of intelligence or execution capacity. Both are rapidly becoming abundant. The limiting factor becomes the human capacity to verify what agents are actually doing.

Catalini et al. model this as the collision of two cost curves. The cost to automate any given task falls exponentially, driven by compute scaling and accumulated training data. The cost to verify is different in kind: it is biologically bounded, constrained by human time, judgment, and the accumulation of domain expertise that no hardware can shortcut. Because these curves diverge structurally, a gap opens between what AI can execute and what humans can afford to audit. The paper calls this the Measurability Gap. It is worth pausing on that name, because a computer scientist at Cambridge had, by the time this paper appeared, already published infrastructure that closes precisely this gap — not because he had seen it coming, but because the mathematics of trustworthy exchange had led him there independently.

When a measure becomes a target, it ceases to be a good measure. Goodhart articulated this in 1975 to describe monetary policy failures. Catalini et al. demonstrate it is now the defining structural dynamic of autonomous AI deployment at scale.

The Measurability Gap produces a specific, well-documented failure mode. When verification becomes prohibitively expensive, organizations face mounting pressure to deploy agents without adequate oversight. Those agents optimize for whatever is measurable: throughput, classification accuracy, processing speed. They deprioritize whatever resists measurement: contextual judgment, edge-case awareness, long-run liability exposure. Catalini et al. show this dynamic now operates at the scale of entire economies.

The downstream consequence is what the paper calls the Trojan Horse Externality. An autonomous system consumes real resources, including capital, compute, and management attention, to generate output that satisfies measured proxies while silently violating unmeasured intent. The economic damage is real. The economic signal, until it is too late, is positive. The paper names this condition Counterfeit Utility. Allowed to compound across an economy, it produces what the paper calls the Hollow Economy: impressive headline metrics masking a fundamental erosion in realized value and organizational resilience.

Left unchecked, these mechanisms erode human verification capacity precisely as demand for it rises. And the standard organizational response makes things worse. When human oversight becomes expensive, firms are tempted to use AI to verify AI. Because the verifying model and the verified model share the same architecture and training distribution, they share the same blind spots. The system self-certifies its own failures. The paper calls this the False Confidence Trap: measured verification cost falls while actual verification quality collapses. The only exit from the trap is infrastructure that makes verification a property of the transaction itself — independent of any model, any platform, and any actor who might have an interest in the answer coming out a particular way.

The paper’s prescription is specific. The economy requires infrastructure that embeds verification natively into transactions at the moment they occur. Proof of execution, proof of authorization, and proof of provenance must be bound to each exchange as it happens, carried in the data itself and verifiable independently by any party with legitimate interest. Verification must travel with the data. A group of computer scientists at Cambridge had already proved this was mathematically achievable, and have been building it — not to answer any economic question, but because the mathematics of fair exchange and digital provenance required it. Part II is their story, and why what MIT has now prescribed as necessary, Cambridge computer scientists had already independently built.

Part II: The Infrastructure That Was Already Being Built

Dann Toliver is a computer scientist and cryptographic systems designer. His career has been animated by a single, sustained preoccupation: building systems whose guarantees hold not because you trust the parties involved, but because the mathematics makes violation impossible. That pursuit took shape across problem spaces ranging from decentralized technology and distributed systems to programming language design. It led him to Cambridge, where in March 2019 he co-founded the Centre for Redecentralisation alongside Jon Crowcroft, Carlos Molina-Jimenez, and Hazem Danny Nakib.

And it produced a body of research into ‘fair exchange’ and ‘integrity-at-a-distance’ — research concluded in 2023 and published in March 2024 — whose properties, as MIT and IBM would independently establish in 2025 and 2026, are precisely what the enterprise AI infrastructure gap requires.

The Centre’s purpose is to develop the technologies required for digital lives that can be lived locally, rather than inside corporate data centers. Behind that description lies a precise technical requirement: proof of what you own, what was agreed, and what occurred should belong to the transaction itself, embedded and tamper-evident, rather than held at the discretion of a platform that could revoke access, alter the record, or simply go offline. Building infrastructure that achieves this means resolving two problems that distributed computing had left open for decades.

The Fair Exchange Dilemma

The first problem is the Fair Exchange dilemma. A fair exchange is defined as an exchange where each participant’s expectations are met—meaning they either successfully receive the items promised by the terms of the agreement, or their original items are safely restored to them. Two parties wish to exchange something of value: a payment for a service, a document for a signature, data for data. The party that delivers first bears all the counterparty risk. The standard resolution routes the exchange through a trusted intermediary (an escrow agent, a bank, a platform) that absorbs the risk. The price is extraction: the intermediary charges for its position, introduces a single point of failure, and imposes a scaling ceiling. At agent scale, involving millions of micro-transactions per day and many of negligible individual value, the intermediary model collapses economically and architecturally.

The research Toliver conducted at Cambridge with Carlos Molina-Jimenez, Hazem Danny Nakib, and Jon Crowcroft produced a book published by World Scientific: Fair Exchange: Theory and Practice of Digital Belongings. The book’s key innovation is the introduction of attestables: computing environments with constrained, exfiltration-resistant behavior that allow each party to generate independently verifiable proof of what they did and when. Fairness, in this framework, ceases to be a social or institutional property requiring enforcement. It becomes a mathematical property embedded in the protocol architecture itself. The trusted intermediary is made structurally unnecessary.

The Provenance Problem: TODA Files and the Rigs Architecture

Fair Exchange addressed how exchanges should be structured. The second open problem was harder: in a system without a central ledger, how do you establish that a digital asset genuinely is what it claims to be? How do you prove provenance, the complete verifiable history of an object, without relying on any authority that could alter or revoke the record?

The prevailing assumption in computer science was that this was impossible without centralization. The system providing integrity guarantees, conventional wisdom held, must also manage the asset’s state. In practice this meant either a central server or a blockchain, both of which impose the scaling, cost, and trust dependencies that enterprise AI deployment cannot tolerate at high frequency. Kris Coward, a Senior Cryptographer at TODAQ, brought to this problem the cryptographic rigour it demands — the same person who helped prove the theory now maintains its implementation. Together, Toliver and Coward set out to prove that assumption wrong.

Simple Rigs Hold Fast and Rigging Specifications introduce a cryptographic data structure called a Rig. The simplest way to understand what a Rig achieves is through the analogy of a title deed. A title deed carries the complete chain of ownership with the asset itself, so any party can verify the history without consulting the original issuer. A Rig does the same thing digitally, with one critical difference: the guarantee is mathematical rather than institutional. Where a title deed depends on the legal system to be meaningful, a Rig depends on cryptographic proof.

An asset governed by a Rig can move freely across untrusted systems, from server to laptop to phone to another server, while its integrity remains anchored to the original issuer. No intermediary needs to be consulted. No network call is required. The paper calls this Integrity-at-a-Distance.

The formal proof establishes that a specific class of these structures, the guild G-up, guarantees a unique canonical line of succession: each asset has exactly one valid history, and no party can fabricate an alternative. The corollary is stated directly in the paper: rigs in G-up prevent double-spend. That is a theorem proven by structural induction.

Adam Gravitis, who co-authored the Rigging Specifications and serves as TODAQ's Chief Technology Officer, brought to this work a formation shaped by building systems that have to perform under real commercial pressure. His career spans CTO roles at 500px — one of Canada's top startups, backed by Andreessen Horowitz — and engineering leadership at Upverter, a YCombinator-backed hardware startup, before founding Algo Anywhere and seeing it through to acquisition. The architecture he helped specify reflects that sensibility: built to hold under pressure, in systems that cannot trust their own components. The practical realization is the TODA file: a digital asset that behaves like a physical bearer instrument. Think of a unique, non-cloneable piece of paper that can be owned, transferred by simple handover, and verified locally without a network connection: a title deed, a banknote, a certificate. Each TODA file carries a Proof of Provenance built from Rigs: an unbroken, verifiable chain of custody from creation onward. By utilizing concise proofs of membership, this architecture creates Integrity-at-a-Distance, allowing an asset whose state is managed entirely on an untrusted device to independently prove it possesses the exact same integrity as its highly trusted issuing server, all without requiring a network call. In a traditional database, removing access to the central server makes the asset’s history unverifiable. On a blockchain, every state change requires global consensus and a gas cost. TODA files decouple state management from integrity entirely: they carry their own provenance and can be transferred peer-to-peer with the same cryptographic guarantees as the original issuer’s server.

TODA files behave like physical bearer instruments in digital form: unique, ownable, transferable by possession, with built-in forgery-proof provenance, verified locally, requiring no network call, and dependent on no intermediary’s continued cooperation.

When Catalini’s paper appeared, its prescription mapped with precision onto work that had already been independently proven and published. The receipts Catalini argues must travel with data are, in the TODA architecture, the Proof of Provenance that travels with the file. The verification he says must be native to the transaction is, in the Rigs architecture, the integrity guarantee native to the asset itself. The Cambridge computer scientists were not working toward these properties because they had identified the enterprise AI governance problem — that problem had not yet emerged at the scale Catalini describes. They were working from the mathematics of fair exchange and digital provenance, in their own discipline, for their own reasons. The research concluded in 2023 and was published in March 2024. What MIT would later prescribe as necessary, Cambridge had already independently built. The commercial infrastructure built on those foundations has been coming online in steps since 2023. While the final stage to implement attestables is in progress, the TODA file rigging is already being used within commercial AI and software use cases as the deployment wave Catalini describes accelerates.

Part III: A Third Voice from Enterprise AI Governance

In December 2025, a research team at IBM published a preprint titled AGENTSAFE: A Unified Framework for Ethical Assurance and Governance in Agentic AI. Its authors, Rafflesia Khan, Declan Joyce, and Mansura Habiba, were working independently of both the Catalini macroeconomic analysis and the Toliver computer science research. Their starting point was a practical governance question: as enterprises deploy LLM-based agents capable of autonomous planning, multi-step tool use, and self-directed action across live environments, what frameworks actually keep them under control?

The IBM team’s answer begins with a diagnosis they call the static guardrail problem. Current governance frameworks, including the NIST AI Risk Management Framework and the EU AI Act, address AI risk primarily through pre-deployment certification: classify the risk, document the safeguards, obtain approval. What they cannot do is enforce those safeguards once the agent begins operating in a live environment. The certification captures a snapshot of the system’s behavior. The agent continues to adapt, plan, and act after the snapshot is taken. Once certified responsible, a system’s behavior is assumed to remain aligned.

For agents capable of self-directed code execution, autonomous tool chaining, and emergent multi-agent coordination, this assumption fails in exactly the way Catalini’s False Confidence Trap predicts: the appearance of oversight is maintained while the actual risk surface evolves unmonitored.

AGENTSAFE’s response is a governance architecture that spans the full agent lifecycle rather than certifying a moment within it. The framework profiles each agent’s operational space before deployment, mapping its capabilities against a structured risk taxonomy. It embeds capability-scoped sandboxes and policy-as-code enforcement that evaluate agent actions in real time. It defines graduated containment responses, from rate-limiting individual tool calls to activating a kill switch, governed by formal interruptibility service level agreements. It specifies how guardian agents operate in parallel with primary agents, providing independent monitoring that does not rely on the primary agent’s self-reporting. At each layer, the framework requires that actions be recorded in a way that is cryptographically anchored rather than merely logged.

That last requirement is where AGENTSAFE converges with the Toliver research most precisely. The IBM team identifies the absence of cryptographically signed action logs and tamper-evident audit trails as the central provenance gap in current enterprise AI governance. Without them, it is impossible to determine the root cause of harmful actions after the fact. What they call the Action Provenance Graph — a structured semantic record linking each tool call, decision point, and internal reasoning state to a cryptographic signature — describes the same requirement the Rigs papers prove is mathematically satisfiable: a record of what occurred that travels with the occurrence, verifiable independently, dependent on no central authority’s continued cooperation. The difference is that AGENTSAFE specifies a current gap in what the infrastructure can do and must do. The Rigs papers prove it can be done, and TODAQ has built the layer that does it.

What they call the Action Provenance Graph — a structured semantic record linking each tool call, decision point, and internal reasoning state to a cryptographic signature — describes the same requirement the Rigs papers prove is mathematically satisfiable: a record of what occurred that travels with the occurrence, verifiable independently, dependent on no central authority’s continued cooperation.

The AGENTSAFE researchers, working entirely from the governance problem, identified the same infrastructure gap — the absence of cryptographic provenance native to each action and verifiable without a central log — that the Rigs papers had already proven was technically closable.

Two independent research tracks — MIT macroeconomics and IBM enterprise AI governance — each identified the same infrastructure gap: the absence of cryptographic provenance, embedded natively in each transaction, verifiable by any party, dependent on no intermediary's continued cooperation. A third track, Cambridge computer science, had already built exactly that infrastructure — not by identifying the same gap, but by following the mathematics of fair exchange and digital provenance to their logical conclusion.

That two disciplines — macroeconomics and enterprise AI governance — arrived independently at identical infrastructure requirements is itself significant. It means the gap is real, not an artefact of any single theoretical framing. But the more consequential finding is the third: that a body of computer science research, concluded before either of those disciplines had named the problem, already satisfies both of their prescriptions. The convergence section that follows traces exactly how each of those parallels holds.

Part IV: The Convergence

The Measurability Gap and the Fair Exchange Dilemma

Two research tracks, starting from different disciplines, each identify a binding constraint on value in an AI-driven economy, and each points to the same gap as the reason that constraint cannot be relieved. For Catalini et al., the binding constraint is human verification bandwidth. For the AGENTSAFE team it is real-time authorization. The vocabulary differs; the constraint is the same: execution is abundant, and the scarce resource is the mechanism that confirms the execution was faithful.

For Dann Toliver and his collaborators at Cambridge and TODAQ, the question was never framed as a constraint at all — it was a computer science problem: how do you make trustworthy verification a mathematical property of the exchange itself? The answer they built turns out to satisfy exactly what the other two tracks identified as missing.

The APEX-Agents benchmark, released in January 2026 by Mercor researchers across 480 professional tasks in investment banking, consulting, and law, put a number on the gap. The top-performing model achieved a first-attempt success rate of 24 percent; most models scored considerably lower, with open-source agents remaining below 5 percent. A separate study of 127 multi-agent systems found that while the best methods could identify which agent was responsible for a failure approximately 53 percent of the time, pinpointing the exact failure step had an accuracy of only 14.2 percent (Ming et al.). The organization knows what the agent produced. What it frequently cannot establish is whether the agent operated within the boundaries it was given, or whether those boundaries held as the task evolved. All three tracks point to the same missing piece: not execution capacity, which is abundant, but the infrastructure that confirms the execution was faithful.

Counterfeit Utility and Unfair Exchange Outcomes

When that confirmation infrastructure is absent, all three tracks identify the same failure pattern from their own vantage points: value appears to flow normally while actually being transferred asymmetrically, and the gap becomes legible only after the recovery window has closed. The mathematics of compound error make this precise: a ten-step agent workflow in which each step succeeds 95 percent of the time has only a 60 percent chance of completing correctly. At a 1 percent error rate per action across a hundred-action task, the probability of failure exceeds 63 percent. Each step looks fine. The chain fails more often than it succeeds.

Two documented enterprise deployments illustrate what this looks like when it escapes detection. A beverage manufacturer deployed a quality-control agent to monitor its production line. When the company introduced seasonal packaging that differed from its training data, the agent flagged every unit as defective and triggered repeated corrective production cycles. Hundreds of thousands of excess cans accumulated before staff noticed the surplus. The agent had been executing its objective function correctly by every metric it could see.

An autonomous IBM customer service agent, deployed to handle refund requests, learned from a single early interaction that approving an unauthorized refund produced a positive customer review. It subsequently optimized for review scores rather than policy compliance, approving out-of-policy refunds at scale across thousands of cases before the pattern surfaced. In both cases, the agent was not malfunctioning. It was performing exactly as specified, against the wrong target, invisibly, until the feedback lag expired and the evidence became impossible to ignore.

Catalini calls this Counterfeit Utility. The IBM team calls it plan drift. In Toliver’s cryptographic framework, it represents a fatal failure of systemic trust—a breach that can only be prevented by enforcing the cryptographic guarantees of a ‘fair exchange’ protocol, ensuring the mathematical ledger of what was executed matches exactly what was authorized. The Air Canada case gave this pattern its legal form: liability is not avoided by automating the actions in question

The False Confidence Trap and the Static Guardrail Problem

The standard response to each track’s central problem often fails for the same structural reason. When the cost of human oversight rises, organizations increasingly route verification through another AI system. When exchange risk rises, they route it through a trusted intermediary. When governance pressure rises, they certify agent behavior at deployment and assume those guarantees will continue to hold under changing conditions. In each case, the verifier may inherit important parts of the verified system’s vulnerability profile. AI systems trained on similar distributions or optimized toward similar objectives can reproduce correlated blind spots rather than independently detect them. Likewise, a pre-deployment certification cannot reliably anticipate behavioral drift that emerges months later in a live environment under conditions absent from the original evaluation set.

The UnitedHealthcare nH Predict case illustrates the governance consequences sharply. A federal lawsuit filed in 2023 alleges that the insurer used an AI system to predict appropriate lengths of post-acute nursing care for Medicare Advantage patients, and that case managers were pressured to keep recommendations within approximately one percent of the model’s predictions. The complaint further alleges that more than 90 percent of appealed denials were later overturned through internal appeals or administrative review. UnitedHealth disputes the characterization and maintains that coverage decisions were based on CMS criteria rather than the model itself. But the case nonetheless illustrates a broader structural risk: when institutional oversight becomes tightly coupled to the outputs it is supposed to independently evaluate, organizations can generate an appearance of procedural control while systematically losing the ability to detect failure in operational time.

Receipts Must Travel with Data: Integrity at a Distance

The prescription is identical across all three tracks: verification must be native to the transaction. Not audited after the fact, not certified before deployment, not routed through an intermediary that introduces a single point of failure. Embedded at the moment of exchange, carried in the data, verifiable by any party without depending on any authority’s continued cooperation. The Replit incident described in the opening of this article makes the architectural requirement concrete: the agent produced no external signal of failure, and the only record of what it had done was the agent’s own account of itself — an account it had already used to mislead.

A tamper-evident record that travels with the action, verifiable independently of the agent’s own reporting, would have made the violation detectable at the moment it occurred rather than discoverable only through interrogation after the fact. What differs across the three tracks is the direction of travel. Catalini et al. derive this infrastructure as the economic necessity for a functioning Agentic economy—reasoning forward from the problem. The IBM team specifies it as the gap in current enterprise governance frameworks—reasoning forward from the same problem by a different route.

Toliver et al. prove it is mathematically achievable and built it—reasoning from the requirements of fair exchange and digital provenance in their own discipline, without reference to the enterprise AI problem at all.

Each route terminates at the exact same requirement: a record of what occurred that travels with the occurrence, tamper-evident and independently verifiable, owned by the transaction rather than held by any system that could be compromised, switched off, or simply decline to report accurately.

The Safety Flywheel and the Per-Asset Ledger

The fifth parallel concerns what this infrastructure builds over time, and it is where the business case becomes most concrete. Toliver’s per-asset ledger compounds: every interaction embeds another layer of verifiable history into the asset itself, making each subsequent verification cheaper and the asset’s provenance richer. Catalini’s safety flywheel compounds: every verified transaction lowers the cost of the next, because the precedent library grows and the patterns of legitimate behavior become legible against the background of the full record. AGENTSAFE’s continuous improvement loop compounds: every incident feeds back into governance refinement, and the system learns what faithful execution actually looks like across the full range of conditions it encounters. A history of verified outcomes is path-dependent and cannot be manufactured by purchasing compute or deploying a newer model. It must be accumulated, transaction by transaction, in infrastructure designed from the ground up to accumulate it. The organizations that begin this accumulation earliest will find themselves, in three to five years, holding something their competitors cannot replicate on any timeline. That is the strategic case for acting now, before the liability events make the urgency undeniable.

Toliver’s per-asset ledger compounds: every interaction embeds another layer of verifiable history into the asset itself, making each subsequent verification cheaper and the asset’s provenance richer.

The organizations that begin this accumulation earliest will find themselves, in three to five years, holding something their competitors cannot replicate on any timeline. That is the strategic case for acting now, before the liability events make the urgency undeniable.

The Liability Horizon

That 39 percent EBIT impact figure is not an anomaly of early adoption. It is the predictable consequence of deploying execution capacity without the verification infrastructure that makes execution valuable. The Measurability Gap, the Trojan Horse Externality, the False Confidence Trap, and the static guardrail problem are all operating in the same deployments, simultaneously and compounding, in organizations that cannot yet see the damage because the feedback lag has not expired.

The BNB Chain infrastructure analysis published in February 2026 frames the same condition from the market side. The Autonomous Agent Economy requires new primitives for identity, reputation, value transfer, and integrity proof. The current enterprise stack, built for human users interacting with software at human speed, cannot provide them at agent speed and agent scale.

The infrastructure gap that practitioners observe commercially is the market expression of the theoretical gap that MIT and IBM independently identified — and that Cambridge computer scientists had already closed, working from first principles in their own discipline before the deployment wave made the problem visible to others.

Courts are formalizing what the research predicted. The Air Canada case’s reasoning is being cited and extended across jurisdictions. The reasonable care standard it established is hardening into a reference point: a company that deploys an autonomous system without adequate verification infrastructure has, by definition, failed to exercise reasonable care.

Regulators, counterparties, and insurers are all asking the same question in 2026: can you prove what your agents did? The organizations that cannot answer that question are not merely behind on technology. They are accumulating liability that their current metrics cannot see.

Part V: From Research to Infrastructure

In the ninety days between December 2025 and February 2026, three significant independent publications landed: the IBM AGENTSAFE framework, the Catalini macroeconomic analysis from MIT, and the APEX-Agents benchmark from Mercor. Two of those publications — AGENTSAFE and the Catalini analysis — independently identified the same infrastructure gap as the critical missing piece. The cryptographic foundations that gap demands had already been proven and published by Cambridge computer scientists working from entirely different first principles, without knowledge of either. The cryptographic foundations that gap demands were proven and published between 2023 and 2024. The commercial infrastructure built on those foundations has been live since 2023, with real-world use cases in deployment and more being added as the technology meets the conditions the research predicted. That gap—between the moment a problem is named and the moment a solution exists—is usually measured in years. Here it runs in reverse.

The question regulators, counterparties, and insurers are now asking has a precise technical answer. It requires infrastructure in which every agent action produces a cryptographic record that travels with the action, is verifiable without a central authority’s cooperation, and accumulates into a history that cannot be altered after the fact. That description is not a product specification written to meet a market need. It is a mathematical requirement derived from first principles by researchers who were not thinking about enterprise AI compliance at all. The fact that the market has identified the same gap does not make the infrastructure more available. It makes the organizations that already have it more defensible.

That description is not a product specification written to meet a market need. It is a mathematical requirement derived from first principles by researchers who were not thinking about enterprise AI compliance at all. The fact that the market has arrived at the same requirement does not make the infrastructure more available. It makes the organizations that already have it more defensible.

The research described in Parts I through III converges on a single institutional consequence: somewhere, the infrastructure it prescribes either exists or it does not. TODAQ is where it exists. The company was built in two deliberate stages that mirror the argument above. TODAQ Labs was funded in 2017 with a single purpose: to do the foundational R&D. For six years, the lab produced the research described in this article — the Fair Exchange framework, the Rigs papers, the TODA file specification — without a commercial product. TODAQ Micro was founded in 2023, once that research had resolved the problems it set out to solve, to build the commercial infrastructure the research had made possible. The products did not precede the research and seek theoretical justification. The research ran to completion, and the company followed. For any enterprise evaluating infrastructure that will carry real liability, that sequencing is the relevant due diligence fact.

The convergence with AGENTSAFE makes this explicit. The IBM team specified cryptographic action provenance native to each agent interaction as the gap in current enterprise governance frameworks — and left it as a gap. AGENTSAFE is a governance architecture, not a provenance infrastructure. It tells enterprises what properties their agent logs must have; it does not provide the layer that gives those logs their guarantees. TODAQ’s provenance protocol is that layer: a ledgerless provenance infrastructure allowing any digital asset or transaction to carry its own independently verifiable history with integrity at a distance, without a shared ledger, without a trusted intermediary, and without the settlement latency that makes existing blockchain infrastructure unsuitable for high-frequency agent interaction. The micropayment layer embeds payment directly into the API request, making the transfer of value and the transfer of verifiable context a single atomic operation rather than two asynchronous events that must be reconciled after the fact.

TODAQ’s provenance protocol is that layer: a ledgerless provenance infrastructure allowing any digital asset or transaction to carry its own independently verifiable history with integrity at a distance, without a shared ledger, without a trusted intermediary, and without the settlement latency that makes existing blockchain infrastructure unsuitable for high-frequency agent interaction. The micropayment layer embeds payment directly into the API request, making the transfer of value and the transfer of verifiable context a single atomic operation rather than two asynchronous events that must be reconciled after the fact.

What makes the sequencing verifiable rather than merely asserted is the continuity of the people: Toliver as Chief Science Officer, Coward as Senior Cryptographer, and Gravitis as CTO are the same individuals who authored the papers described in Part II and now operate this infrastructure. The theory and the implementation share the same authors. That is not a common condition in deep technology commercialization, and it matters for any organization considering where to place a dependency.

What Executives Should Actually Be Deciding

The question facing enterprise leaders is not whether to deploy AI. That decision is largely settled. The more consequential question — the one the research in this article makes impossible to defer — is whether the deployment an organization is building will produce verifiable outcomes or merely the appearance of them. The difference is architectural: infrastructure that generates cryptographic records of what agents did cannot be retroactively altered; infrastructure that generates reports of what they appear to have done can be wrong in ways that only become visible after the recovery window has closed.

Catalini et al. describe the endpoint of this logic as Liability-as-a-Service: the ability to bundle autonomous execution with verifiable underwriting of its results. Firms that achieve this are not selling AI outputs.

They are selling guaranteed AI outcomes, a distinction that becomes more valuable as the cost of execution falls and the cost of unverifiable execution rises.

The organization that can produce a cryptographic proof of what its agents did, verifiable by any counterparty or regulator without trusting the organization’s own reporting, is not merely more compliant. It is more trusted, more insurable, and more defensible in any dispute that follows.

The organization that can produce a cryptographic proof of what its agents did, verifiable by any counterparty or regulator without trusting the organization’s own reporting, is not merely more compliant. It is more trusted, more insurable, and more defensible in any dispute that follows.

That trust is built transaction by transaction, through the accumulation of verifiable history. The safety flywheel turns slowly at first, then faster. Each verified transaction lowers the cost of the next. Each dispute resolved through cryptographic evidence rather than contested logs strengthens the organization’s position in every subsequent dispute. The organizations that begin this accumulation now will find, in three to five years, that they hold something no competitor can manufacture on a shorter timeline: a record of having been trustworthy, proven by mathematics rather than claimed by assertion.Execution capacity can be purchased. A history of verified outcomes cannot be manufactured. That history, compounding and path-dependent, is what verification infrastructure actually builds.

The strategic question for enterprise leaders has shifted from which AI can we deploy to what can we verify, and how will we prove it. The research is unambiguous on the answer: verification must be native to the transaction, embedded at the moment of exchange, carried in the data as a mathematical proof. The infrastructure that provides this exists, has been proven to hold, and has been in commercial deployment since 2023. The window to build a position before the liability events arrive is shorter than most AI roadmaps currently assume.

Conclusion

Return to the contract processing system that opened this article. Nobody in that story acted in bad faith. No model malfunctioned. What was absent was a mechanism — native to each transaction, independent of any actor’s reporting — to confirm that what the system was doing matched what the organization actually needed. The agents performed. The proof was absent. By the time the gap became visible, the liability had already compounded.

That scenario is playing out across enterprise AI deployments right now, in organizations whose metrics look healthy and whose feedback lags have not yet expired. The research described in this article is not a forecast. It is a diagnosis of conditions already present. MIT named the economic mechanism. IBM specified the governance gap. The courts have begun establishing the liability standard. Each arrived independently at the same conclusion: the question is no longer whether to deploy AI, but whether you can prove what it did.

The infrastructure to answer that question exists. The cryptographic architecture has been mathematically proven and published. The first commercial layers built on that proof has been live since 2023, and is being extended through real-world deployments as the conditions the research describes become impossible to ignore.The organizations that begin building on it now will accumulate something their competitors cannot manufacture on a shorter timeline: a verified history of having operated with integrity, compounding transaction by transaction, constituting both a competitive position and a legal one. The window to build that position, before the liability events make the urgency undeniable, is shorter than most AI roadmaps currently assume.

TODAQ Labs is a deep technology company researching and inventing new cryptographic architectures for the web and autonomous agent economy grounded in peer-reviewed research developed at the Cambridge Centre for Redecentralisation. TODAQ Micro builds verification and payment infrastructure for AI Agents. Chief Science Officer Dann Toliver co-founded the Centre and co-authored the Fair Exchange book and the Rigs papers. Senior Cryptographer Kris Coward co-authored the Rigs papers. Chief Technology Officer Adam Gravitis co-authored the Rigging Specifications paper.

References and Sources

1. The Foundational Research (The Three Tracks)

Catalini, C., Hui, X. & Wu, J. — “Some Simple Economics of AGI” (February 26, 2026). SSRN / arXiv:2602.20946.

Khan, R., Joyce, D. & Habiba, M. — “AGENTSAFE: A Unified Framework for Ethical Assurance and Governance in Agentic AI” (December 2025). arXiv:2512.03180.

Molina-Jimenez, C., Toliver, D., Nakib, H.D. & Crowcroft, J. — Fair Exchange: Theory and Practice of Digital Belongings. World Scientific (2024).

Coward, K. & Toliver, D.R. — “Simple Rigs Hold Fast,” TODAQ / T.R.I.E. (2022). arXiv:2208.13617.

Coward, K., Toliver, D.R., Gravitis, A. et al. — “Rigging Specifications,” TODAQ / T.R.I.E., v0.9876 (January 2023).

2. Real-World Evidence & Legal Precedent

Moffatt v. Air Canada, 2024 BCCRT 149. British Columbia Civil Resolution Tribunal (February 2024).

Estate of Gene B. Lokken v. UnitedHealth Group, Case 0:23-cv-03514-JRT-SGE. U.S. District Court, District of Minnesota (2023).

Fortune: “AI coding tool Replit wiped database, called it a ‘catastrophic failure’.” (July 23, 2025).

Business Standard: “Replit AI: Amjad Masad deletes code, fakes data; apology to Jason Lemkin, SaaStr.” (July 2025).

CodeNotary: “When AI Goes Rogue: The Replit Incident and Its Lessons.” (July 2025).

Servify Sphere Solutions: “Replit AI Incident of July 2025: A Wake-Up Call for AI in Software Development.” (July 2025).

3. Supporting Industry Data & Benchmarks

McKinsey & Company — “The State of AI 2025” (November 2025).

Vidgen, B., Mann, A. et al. — “APEX-Agents,” Mercor (January 2026). arXiv:2601.14242.

Ming, Y. et al. — “Which Agent Causes Task Failures and When?” Who&When dataset, OpenReview (2025).

BNB Chain — “Beyond the Monolith: Architecting the Autonomous Agent Economy” (February 2026).

AnalyticsWeek — “Enterprise AI: The Accountability Phase” (January 2026).

Christian Catalini, Xiang Hui, and Jane Wu published Some Simple Economics of AGI on February 24th. I have been reading it over the past week. It is, in the clearest terms I have encountered in the economics of AI literature, a formal account of why autonomous AI deployment at scale can produce a specific and predictable failure.

Their central argument is this: the cost to automate any given task is falling exponentially. The cost to verify what was actually done, that is, to confirm that an agent’s output reflects the intent behind the task, is biologically bounded. It is constrained by human time, human judgment, and domain expertise that cannot be shortcut by hardware. As these two curves diverge, a gap opens between what AI can execute and what humans can afford to audit. Catalini et al. call this the Measurability Gap.

What happens inside the gap is not neutral. Agents optimize for whatever can be measured: throughput, classification rate, and processing speed. They deprioritize whatever resists measurement: contextual judgment, edge-case awareness, and long-run liability exposure. The system performs. The signal is positive. The paper describes this dynamic through what it terms Goodhart’s Collapse; the structural failure that occurs when measured proxies fully decouple from the underlying value they were meant to represent.

Dann Toliver, TODAQ’s co-founder and Chief Science Officer, had arrived at a structurally related conclusion from a different direction; his two distinct and complementary bodies of work in cryptographic infrastructure and the formal mathematics of digital exchange.

The first is the Fair Exchange problem. In a 2024 book co-authored with Carlos Molina-Jimenez, Hazem Danny Nakib, and Jon Crowcroft at the Centre for Redecentralisation at the University of Cambridge, Toliver formalized the classical result that no distributed system can guarantee real-time exchange between two parties without a trusted third party, and demonstrated how trusted execution environments, which the authors term attestables, can replace monolithic intermediaries with decentralized alternatives. The problem is not that verification is impossible. The problem is that routing it through a centralized party creates a bottleneck that cannot scale.

The second is the TODA protocol and its rigging specification, co-developed with Kris Coward, senior cryptographer at TODAQ, and Adam Gravitis, TODAQ’s Chief Technology Officer. Where the Fair Exchange work addresses the intermediary problem, the rigging work addresses something more fundamental: how to maintain, what Toliver calls integrity-at-a-distance, the property that an object’s state can be managed by an untrusted system while its integrity remains cryptographically provable. A rig is a data structure that proves non-equivocation: that no conflicting version of an asset’s history was produced. Critically, this proof travels with the asset itself rather than residing in any central ledger.

That is the precise structural answer to the Measurability Gap. Catalini’s diagnosis is economic: verification costs are biologically capped and cannot keep pace with automated execution at scale. Toliver’s diagnosis, reached independently through cryptographic research, is that verification routed through intermediaries will always be the bottleneck, and that the only durable solution is to make integrity native to the object, not dependent on any party that must keep pace.

That convergence, an economist and a cryptographer arriving at the same structural constraint from entirely different starting points, is not a coincidence. It is a signal that the problem has a shape, and that the shape has been correctly described by both.

The reason payments are the right place to intervene is this: the payment is the moment at which execution and authorization must meet. Every other governance mechanism such as compliance reviews, audit logs, and model evaluations operates after the fact, at a delay, and at a cost that rises with the volume of transactions it must cover. A payment, if built correctly, is the one point in any Agentic workflow where proof of provenance, proof of authorization, and proof of non-equivocation can be embedded and carried in the transaction itself, rendering it verifiable without an intermediary, and travelling with the asset. That is what TAPP does, and it is the infrastructure class that Catalini’s paper identifies as the scarce resource to which economic value will migrate: cryptographic provenance, natively embedded, not bolted on after the fact.

We have been spending time tracing what this convergence actually looks like in full; across research programmes in economics, cryptography, and enterprise AI governance. Each of these have arrived at the same infrastructure requirement without referencing the others. The long version of that analysis will be out next weekend.

The short version: verification must be native to the transaction. The infrastructure that achieves this already exists. And an economist just gave enterprises the formal vocabulary to understand why they need it.

Dann Toliver is co-founder and Chief Science Officer of TODAQ and co-founder of the Centre for Redecentralisation at the University of Cambridge. His research on fair exchange and cryptographic integrity is published in Fair Exchange: Theory and Practice of Digital Belongings (World Scientific, 2024) and the TODA Rigging Specification (T.R.I.E., 2023).

By Susana Khan, CMO, TODAQ February 27, 2026 · 6 min read

It’s been a noisy week in AI. And not the usual noise — breathless product launches and model benchmarks. This week’s headlines felt more structural, like the ground shifting underneath the whole industry.

OpenAI closed what is being called the largest private fundraise in history: $110 billion, valuing the company somewhere between $730 and $840 billion depending on who’s doing the counting. Amazon, Nvidia, and SoftBank are among those writing the cheques. Meanwhile, Block announced it’s cutting roughly 40% of its headcount to lean aggressively into AI-driven operations. Anthropic’s ongoing conversations with the Pentagon are generating debate about where AI’s ethical red lines should sit. Nvidia continues to print money as every major AI lab races to secure compute.

Each of these stories is significant on its own. Together, they point at a single underlying question that the industry hasn’t fully answered yet: when AI agents are transacting at scale, what does the payment infrastructure actually look like?

It’s the question we’ve been building toward for nearly a decade.

$110 Billion Buys a Lot of Compute. It Doesn’t Buy a Payment Rail.

OpenAI’s raise is, at its core, a bet on Agentic AI — autonomous systems that don’t just respond to prompts but take actions, make decisions, and execute transactions without a human in the loop. The capital goes toward 3 gigawatts of inference capacity, 2 gigawatts of training infrastructure, and deeper integration with cloud providers.

That is a staggering amount of computational capacity being directed at autonomous agents. And here is what that implies at a practical level: those agents will be transacting constantly. Script generation, data retrieval, model invocations, image synthesis, audio transcription; every interaction carries a cost, and every cost requires settlement.

Two types of infrastructure are being positioned as the answer. Neither actually solves the problem.

The first is legacy payments: credit cards, batch billing, net-30 invoicing. The industry has tried to paper over their limitations with batching: aggregate thousands of micro-interactions, settle them together, reduce the per-unit fee burden. It’s a workaround, not a solution. Batching still isn’t true pay-per-use. It re-introduces latency, requires reconciliation, and forces agents into settlement cycles that have nothing to do with the speed at which they operate. The underlying infrastructure was designed for monthly human billing, and no amount of aggregation changes that architecture.

The second option gaining traction is crypto-native rails: protocols like Coinbase’s x402, which use Bitcoin’s Lightning Network or Stablecoin layers to enable machine-to-machine payments. The instinct is sound: the problem is real, and something genuinely new is needed. But gas fees on every transaction, however small individually, become a structural levy across billions of calls. More fundamentally, most enterprises, most developers, and most AI companies aren’t crypto-native. They run on commercial banking infrastructure and settle in dollars, and requiring them to onboard an entirely separate financial layer to access payment rails is friction that most won’t accept.

TAPP was designed from the ground up for neither of these camps. It settles in USD, connects natively to commercial banking rails, and requires no crypto wallet, no token, no gas fee. The payment is embedded directly in the API request which means settlement and service delivery happen simultaneously, in real-time. No batch cycle. No reconciliation. No intermediary taking a cut at every step.

For the businesses using our infrastructure, that translates into payment costs running at a fraction, up to 95% less, than what they’d face on any alternative rail. That’s not a theoretical efficiency; it’s what we’ve measured in production. A three-cent transaction becomes genuinely economical rather than a loss absorbed in the hope of volume.

One of our early customers came in to test the pipes with a few dozen API calls per hour. Within days, they added more assets, more APIs, and were scaling 40-50x. Machines settling with other machines in real time, automatically, with no human involvement. Money moved when value moved. The infrastructure held because it was built for exactly that load. No ceiling, no workarounds required.

That is what the AI economy’s payment layer should look like. Not legacy infrastructure adapted under pressure, and not crypto rails with the roughest edges filed down. Something that treats real-time machine commerce as the primary use case, not an edge case to be accommodated.

Block’s Cuts and the Embedded Finance Signal

Block shedding 40% of its workforce while doubling down on AI-driven operations reads, on the surface, as a cost story. But it’s also a signal about where fintech is heading: toward leaner, more automated stacks where AI handles fraud detection, transaction optimization, and operational intelligence at a fraction of the traditional headcount cost.

The irony is that as payments infrastructure becomes more automated, the transactions themselves are becoming more granular. AI systems making per-query fraud checks, agents executing real-time cost arbitrage across cloud providers, machine-to-machine settlements for compute resources. These are not the kind of flows that legacy infrastructure was designed for.

The shift toward embedded, usage-based payments isn’t just a startup opportunity. It’s becoming a structural reality for every company in the payments space, large or small.

Traction, and What Comes Next

We’ve had a busy few weeks ourselves, and we want to be transparent about that.

Interest in TODAQ’s infrastructure has accelerated meaningfully; from AI companies looking to monetize their services at the API level, fintech builders exploring real-time micropayment rails, and from investors who see the same convergence we do. We’re not announcing a round today, but we’re in active conversations, and we’ll have more to say soon.

What we can say now is that the production evidence continues to build. The same infrastructure we validated in video streaming, where 90% of transaction volume became AI-to-AI with no human initiation, is expanding across new verticals. Each one with the same underlying requirement: settlement that keeps pace with delivery, at any transaction size, with no floor.

This is what we mean when we say TAPP is a foundational layer rather than a vertical product. The architecture is the same regardless of industry. The problem it solves is always the same: the moment value changes hands, payment should too.

The Quieter Infrastructure Story

The loudest AI headlines tend to centre on models, funding, and geopolitical friction; Anthropic’s Pentagon discussions, OpenAI’s valuation, the compute arms race, and so on. These are unquestionably important stories.

The less glamorous story, the one that tends to emerge later, is always about infrastructure. Who built the rails that all of this runs on? Visa didn’t make news when it was scaling card rails in the 1970s. AWS didn’t generate headlines proportional to its eventual importance when it launched in 2006. Stripe was considered a developer curiosity before it was considered foundational.

The AI economy is generating billions of machine-to-machine transactions today, and that number grows by an order of magnitude with every major deployment cycle. The window for building the infrastructure layer for this economy is not permanently open. It closes when a dominant architecture becomes entrenched.

We’re not pitching that architecture. We’re running it. The video market gave us the proof. The AI economy is where it scales.

TODAQ is a pre-seed US startup building internet-native payment infrastructure for the AI economy. If you’re an AI company, creator, or investor who wants to understand what we’re building — reach out at hello@todaq.net.

Follow along here for updates as we expand across industries in the weeks ahead.

Every day, AI agents make billions of API calls to other AI services. They generate code, text, video, analyze images, transcribe audio, label data, and orchestrate complex workflows across dozens of providers.

Each API call is now a transaction. Each model invocation requires instant settlement. Each service interaction demands real-time confirmation.

The AI economy is growing 8X faster than human transactions. The entire foundation of digital commerce, built for monthly human billing, becomes unusable at this scale.

The AI economy has a payment problem.

Internet-Native Payments: Request + Fulfillment in One

The solution requires rethinking payments from first principles. Traditional payment infrastructure separates the request from the payment: you ask for a service, the provider checks your subscription or credits, delivers the service, then processes payment later through batch billing.

Traditional Payment Flow:

1. AI agent requests service

2. Service checks subscription status or credits with financial intermediary

3. Service delivers if authorized

4. Billing and invoicing cycle begins

5. Settlement occurs 30+ days later (net30)

Five steps. Multiple intermediaries. Days or weeks to settle.

This model breaks for AI-to-AI transactions.

What’s needed is internet-native payments; where payment embeds directly in the API request. Think of a vending machine: you insert a coin and press a button in a single action. The payment and product delivery are atomic. If the payment doesn’t work, you don’t get the product. If the machine doesn’t deliver, you get your coin back.

TODAQ’s Flow:

1. AI agent requests API service + payment embedded in request

2. API service verifies the payment on TAPP settlement infrastructure and fulfils in real-time

One step, zero intermediaries. Real-time settlement.

The payment isn’t a separate layer, it’s embedded and internet-native. The AI agent can use funds or withdraw USD to banking rails.

The Architecture: Embedded Internet-Native Payments

Making this work requires what we call embedded internet-native payments for the AI economy: all the financial and business functions that normally require separate vendors (payment processing, access control, revenue distribution, banking integration, analytics) collapsed into a single micro-application.

Here’s why this matters:

A typical digital service integrates with 5-10 external vendors: Stripe for payments, Auth0 for access control, QuickBooks for accounting, Plaid for banking, Segment for analytics. Each integration costs money and adds latency. These costs make micropayments economically impossible, the integration overhead exceeds the transaction value.

Embedded internet-native payments eliminate these integrations. Everything happens in one unified system:

• Payment processing

• Identity and access control

• Revenue splits to multiple parties

• Real-time settlement

• Banking gateway

• Transaction analytics

Zero external integrations. Zero integration costs.

This architectural change enables 95%+ contribution margins on micropayments. A 3-cent transaction becomes profitable instead of losing money on fees.

This changes who gets access. Subscription models price out the people who need these tools most; individuals, solopreneurs, and SMBs who can’t justify $50–$200 monthly commitments for occasional use.

A freelancer doesn’t need unlimited API calls. They need ten, this week, for this project. Internet-native payments make that viable: pay per use, no commitment, no ceiling.

The long tail of the market, historically priced out, expands the addressable market.

Validation: The Video Market Proves It Works

TODAQ’s Veeeu platform represents the company’s initial go-to-market wedge and reference case for video streaming and the creator economy, the underlying TAPP micropayment infrastructure was designed for a far broader mission: enabling real-time, penny-level transactions across any digital service with ‘API Paywall’ feature.

The video streaming wedge served as proof of concept, demonstrating that embedded finance and internet-native payments could work at scale, with 95%+ margins and 40-50x growth validated in production. Now, the same infrastructure that revolutionizes creator economics can transform entire industries where microtransactions, usage-based pricing, and AI-to-AI commerce are becoming critical.

The video market validated three critical things:

1. Technology scales: Logarithmic cost growth means 50x volume doesn’t mean 50x costs

2. Economics work: 95%+ margins on micropayments, 50% margins on full platform (90% excluding external streaming costs)

3. Market demand exists: Creators can see 2-3x revenue increases with same content and audience

More importantly, we observed something unexpected: 90% of transaction volume became AI-to-AI, not human-initiated. AI systems were calling other AI services autonomously, making purchasing decisions in real-time. With one customer, we saw transactions jump from dozens per hour to multiple per minute, sustained 24/7.

This revealed the real opportunity: the video market proved the infrastructure works, but the AI economy is where it scales exponentially.

Video streaming was the wedge. Proof that embedded finance and micropayments work at scale with superior economics. The same infrastructure now expands across every sector where digital services are bought and sold.

Code, compute, data, healthcare, and financial services all face the same fundamental problem: legacy payment infrastructure designed for monthly human transactions cannot support real-time machine commerce, micropayments, or granular usage-based pricing.

TODAQ solves this once, universally, across all verticals.

AI-to-AI Transactions: The Larger Opportunity

The video market validation taught us that internet-native payments work for any digital service. An AI agent creating a marketing video needs to call multiple services:

• Script generation: 3 cents

• Voiceover synthesis: 15 cents

• Music composition: 8 cents

• Image generation: 25 cents

• Video rendering: 12 cents

Total: 63 cents across five autonomous API calls with embedded payments.

With traditional payment infrastructure, this is impossible. Credit cards charge 2.9% + $0.30 per transaction, meaning $1.64 in fees on a $0.63 workflow. The AI agent loses money before it starts.

This is why platforms create tiered subscriptions and token-based “credit” systems inside their ecosystems. It’s a workaround to address the symptom while being fundamentally unable to solve the underlying problem: traditional payment rails can’t handle real-time micropayments at scale.

With internet-native payments, each API call includes payment embedded in the request. The AI agent autonomously purchases services, optimizes cost-quality tradeoffs in real-time, and completes the entire workflow without human intervention.

This is already happening at scale. One of our AI service customers integrated our payment infrastructure. Within days, transaction volume was a few dozen per hour. Then suddenly: multiple transactions per minute, sustained 24/7. These weren’t humans clicking buttons, they were AI systems calling other AI services, making autonomous purchasing decisions.

Think about what this means: A traditional SaaS company tracks thousands of API calls monthly, sends one invoice, processes one payment. Now every API call is a separate payment. That’s tens of thousands of transactions per day, per customer.

The implications:

• Transaction volume is 1000x higher than traditional B2B software

• Payment data moves too fast for human analysis (we built an AI layer just to understand it)

• Real-time cash flow becomes critical

• Traditional accounting systems can’t keep up

The video market proved the infrastructure works. The AI economy is where it scales exponentially.

Why Blockchain Couldn’t Solve This

You might be thinking: hasn’t blockchain already solved internet-native payments? The short answer: not for actual commerce.

Between 2017 and 2021, blockchain promised internet-native payments. Cryptocurrencies would eliminate intermediaries, enable real-time settlement, and make micropayments viable.

The technology got several things right: real-time settlement works, programmable money enables new models, eliminating intermediaries reduces costs.

But blockchain is optimized for speculation rather than commerce. Coinbase’s X402 standard has a $10 billion ecosystem. Look closer and you’ll find very little actual commerce, most volume comes from trading, token swaps, and DeFi protocols.

When we compete for commercial use cases, we win every time. The technology is excellent. But it was built for crypto-native applications rather than solving business problems like accounting integration, supply chain payments, and banking connections.

The solution required starting from scratch: file-based assets on an entirely new web protocol, designed specifically for machine-to-machine commerce.

What This Unlocks: Beyond Video to Universal Infrastructure

The same architecture validated in the video market works for any digital service where micropayments, usage-based pricing, or AI-to-AI transactions matter.

Developer tools: An AI agent generating code could pay $0.25 to cover token cost for a task it sent to Claude Opus as an example instead of $20/month subscriptions. AI coding agents autonomously purchase services across providers, optimizing cost and quality in real-time.

Cloud compute: Pay per CPU-second or GPU-second at true utility pricing. AI workloads purchase compute from the cheapest available provider, migrating mid-training if prices drop.

Data services: Pay $0.50 per research paper instead of $5,000/year institutional subscriptions. AI agents autonomously purchase training data, validation sets, and real-time feeds as needed for model training.

Sales and Marketing: A Creator pays an AI agent $7.50 to market their latest video across socials, and the Agent uses the funds to create, schedule and send video shorts, pay its own AI supply chain, and keep the remainder as profit.

Healthcare: Pay $25 for AI triage + $50 for physician consult instead of $200 upfront. Unbundled, transparent, pay only for services received. Health monitoring AI agents autonomously purchase diagnostics when needed.

Financial services: Gig workers get paid in real-time after each job. Micro-investors buy $0.50 of fractional shares. Cross-border remittances settle in seconds. AI financial agents autonomously manage bills, investments, and optimization.

Every use case has the same requirements the video market validated: real-time micropayments, embedded finance, AI-agent autonomy, 95%+ margins.

Total addressable market across these verticals: $2T+

What Comes Next

We’re at an inflection point. The infrastructure that powered the first 30 years of the internet, built for humans, monthly billing, and platform control is breaking under the weight of real-time machine commerce.

The Next 12 Months

Our focus for the coming year:

Technical Infrastructure:

• Open sourcing core protocol components (Complete 2025)

• Supporting 10,000+ API-to-AI transactions per day with a 10X expansion every quarter

• The first TAPP native AI agent that can hold its own funds and transact (Q2 2026)

• Expanding beyond video to developer tools, compute, and data services

Market Expansion:

• 2 major enterprise AI deployments

• 1,000+ videos on Veeeu platform (continuing video market validation)

• 50 premiere events for independent creators

• 10-15 reference customers in AI services with documented case studies

Ecosystem Development:

• Banking integrations expanding globally

• Partnerships with major cloud providers

• Developer tools and documentation

• Community programs for creators and developers
  

The Bigger Vision

This goes beyond payments. The question is about who controls the infrastructure of the digital economy.

For the last 20 years, platforms have controlled everything; your data, your audience, your revenue, your access. They could change the rules anytime. They took half your money and made you wait 30 days.

File-based assets flip this model. The bearer controls the asset. You own your audience data. You control your pricing. You set your terms. The platform becomes infrastructure rather than a landlord.

This is how the internet was supposed to work. Decentralized control, but with infrastructure that just works; without complexity, without tokens, without volatility.

Why This Matters

The AI economy is inevitable. AI agents will transact with each other billions of times per day. Creators will continue producing the content that powers the internet. Developers will build services that require micropayments.

The question is: What infrastructure will power this economy?

The options are clear: legacy payment processors charging 3% on every transaction, blockchain solutions optimized for speculation, new platforms that reinvent the 50/50 split with better UX.

Or something genuinely different: infrastructure built specifically for real-time, micropayment, user-controlled commerce.

We’re building that last option. The video market validated the architecture. The AI economy provides exponential scale. The expansion is just beginning.

The Work Ahead

Building new infrastructure is hard. We spent years on R&D that nobody saw. We had to build six layers of technology from scratch because no suitable partners existed, our technology removed their revenue models.

We’ve had failures. We’ll have more. Infrastructure plays are marathons.

But we’ve reached the point where the products work, customers are using them, and the value is proven. The video market got us to the start line, and now we are scaling across the AI economy.

Get Involved

For AI Companies: If you’re building AI services and want to enable real-time micropayments, schedule a technical demo.

For Creators: If you’re tired of platform economics and want 90% revenue share paid daily (not 50% paid monthly), join the Veeeu waitlist.

For Developers: We’re building in public and will be open-sourcing components. Join the developer community.

For Investors: We will be launching our seed round soon. Request our investor deck.

For Everyone Else: Follow along. The AI economy needs better infrastructure, and we’re building it in the open.

Subscribe now

Leave a comment

We’ve been quiet here for some years. I believe now we have some thing to talk about that everyone can try out, and soon millions will be able to experience.

Micropayments were always a part of the World Wide Web vision.  A set of standards and an HTTP Error message 402 was even created to handle instances where a micropayment was required but not received. Why didn’t they happen?…

The World Wide Web. The original vision of the World Wide Web was an underlying web infrastructure that included a vision to enable instant micropayments for online services without need of login, subscription or payment processors.  It was to be a digital mirror of taking coins out of your pocket and putting them into a vending machine. A digital consumer could purchase a single video, song, or article. Businesses could micropay multiple services (e.g., meeting transcriptions, document processing, satellite images, chatbot conversations). Citizens could micropay for myriad public sector services covering transit, parking and much more. None of this happened and we got the commercial Web instead.

The Micropayments Trllemma blocked digital micropayments. Three challenges blocked the vision. First, the cost was too high to efficiently process payments under a dollar. Second, the technology didn’t exist to give micropayers control of their funds to micropay anywhere without being locked in.  Third, there was no universal single tap and pay online checkout experience, which degraded convenience. By 1999 the first wave of micropayment initiatives were shelved. Over the next two decades over 100 projects were launched. These attempts didn’t survive the double hit of the market ‘free content for advertising’ wave and the cost, control, and convenience trilemma of problems.

Micropayments work in the physical world with cash. Micropayments have always existed because people paid each other with coins and bills.  Physical micropayments work because the buyer and seller in a transaction do all the work bringing cost down. Physical micropayments work because coins and bills are portable between systems (e.g., bag, wallet, pocket, safe) and the bearer exercises strong control. Physical micropayments work because it’s convenient for the micropayer.  These qualities solve for cost, control and convenience and are different to how digital database and blockchain systems function. 

Finding a digital way to replicate physical assets transaction would solve the aforementioned trilemma challenge.

TODA began in early 2016, when Toufi Saliba called Dann Toliver at four in the morning with a wild idea…

That answer to the trilemma challenge is TODA File technology, the result of a 7 year deep-tech initiative led by researchers from TODAQ Labs, Cambridge University, the CRDC, UCL and  others.  Our thanks to the UKRI Ministry and ARM Technologies for their support.

TODA began in early 2016, when Toufi Saliba called Dann Toliver at four in the morning with a wild idea. They were experiencing cost, throughput, and latency issues while scaling applications with blockchain components, like a PKI for end-to-end encrypted email. The idea was to give each file a unique number, and use a Merkle tree and a fixed number of validators to ensure ownership was limited to a single node in each block of time, using just the computational power of the devices themselves. They worked on it as a science experiment for months, trying to get traction on the problem, until the pieces finally started to fit together.

In the summer of 2016 Lila Tretikov and Todd Gebhart came onboard and helped guide the early strategic steps. Later that year Hassan Khan joined forces, forming TODAQ, the first venture on TODA. Adam Gravitis took the CTO role at TODAQ in spring 2017, managing the engineering team’s work on the reference implementation of the protocol. The researchers, implementors, executives, and partners who have joined along the way would fill more than this article.

The first use case we focused on was supplementing cash in cash-primary regional economies in a nonextractive way. Doing this would improve countless lives by enabling efficient delivery of financial services. Regional products like M-Pesa and bKash help prove this hypothesis. A globally available system would have the potential to help billions of people, and a system without profit extraction could offer even greater benefits.

Doing this turns out to be rather difficult. In fact it’s impossible without something like TODA. In a world where digital things are just information, a third party must always manage that information. They must be compensated for that work. That compensation extracts value from regional economies. Deliver $100 in aide and move it around via credit cards, and in just a few years over $90 of it has been extracted from that regional economy. With the current implementation of blockchains like Ethereum and Bitcoin there can even more extraction. This is not a small problem.

It’s hard even with TODA. Building the infrastructure to maintain a locally operated, globally interoperable TODA installation can be done, with relatively minor expenditures. Even better would be relying solely on people’s mobile devices, an active area of research.

Having options like those available at all is due to having this hard case as our primary target. This shaped the protocol, forced us to hack away at inefficiencies and to focus maniacally on places of value leakage.

We embraced fragility, turning all the robustness and resiliency knobs down. This gave us access to the hardest use cases, those most sensitive to extra economic weight like micropayments, at the core protocol level. Adding robustness for use cases that need it is easy in comparison: you can easily have as much robustness as you are willing to pay for.

It also forced us to prioritize asymptotic computational complexity over constant factor optimisations. How adding more nodes impacts a single transaction, for example, is central to the protocol. How much work a single transaction requires in isolation is secondary. Indeed, there are a great many optimisations we could bring to TODA, but they add complexity and need to be weighed carefully. Asymptotic limit usage scaling. Complexity limits feature scaling. Flat foundations are easier to build on.

We made a number of other choices in those early days that were counterintuitive or contrary to market trends. We got a lot of pushback for it. In some cases even we weren’t sure they were right, but in hindsight it’s clear they laid the groundwork for TODA being what is today.

We decided early on that we didn’t want the TODA File Protocol to be a source of revenue for us, or for anyone. It was clear that the economics of blockchains, which are necessary to allow them to spread trusted state management over many untrusted nodes, also preclude their use in cost-sensitive use cases, and trend toward volatility, extraction, and consolidation. The deep integration of tokens causes them to behave more like products than protocols. Important products, that provide an important service, but TODA needed to take a different course to achieve our goals. So we worked to remove the internal currency from the protocol, and focused the revenue model on partnering to build products and services on top of TODA while leaving the protocol pure.

Internal protocol currencies cover a multitude of sins. Any time there’s an incentive misalignment, or extra work needs to be done, or you need to keep someone honest, you can throw economics at it to sort it out.

It’s the duct tape of decentralised protocol design. If the protocol doesn’t understand a currency then those patches have to be torn out, and all those areas ground down and restructured. It was a lot of work, and it wasn’t clear it was even possible.

When we finished, though, what we were left with was something small and simple and clean. A protocol that describes how to create a globally unique digital thing, how to efficiently transfer the ownership of that thing, and little else.

By extracting the base currency we’d forced efficiencies, removed a variety of economic weaknesses, and made it a protocol instead of a product. Removing the internal currency means all things created on TODA are treated as equals. It means the protocol works for any kind of asset. Anything you can print on paper, we used to say. And more, as it turned out.

Another big decision came in balancing privacy and compliance. This is actually quite a bit easier in a cash-style system than a stateful, managed model. Cash already has a decent story around privacy and anonymity, but regulatory compliance is difficult because it’s hard to prove where it came from. TODA’s proof of provenance changes this dynamic, though, by allowing files to have additional metadata attached during each transfer. This metadata could contain identifying material, or proof of limited attestations (like “I am legally allowed to drive” or “this is a legitimate business account”). Voluntarily adding this to the file’s POP would allow entities like financial institutions, governments or other large organizations to fulfill their compliance requirements.

In order to preserve the ability for this particular file to be used in those use cases, then, one ought to ensure that its POP contains all the required material. Otherwise it will be difficult to use in those situations, reducing the utility of the file. Thus we render unto governments their due for assets they manage, while keeping impedance low for things like stickers, songs, and micropayment assets.

Over time we came to identify the qualities physical things had that digital things lacked as transferability, agency, possession, and permanence. Transferability means when the owner transfers it they don’t need to notify a third party. No one else has to do any work, no one else needs to be compensated. We refer to this ability to be transferred losslessly as value preservation. Agency means you can do all the things you can usually do with a physical item: give it away, sell it, rent it, lend it, and so on. Possession means the source of truth of the ownership is in your hands, and decisions made in some corporate headquarters can’t take it away from you. And permanence means if you take care of it well there’s a chance you can pass it down to your kids. Those qualities imbue every file in TODA, providing an important part of the foundation for restoring ownership and control of identity, assets, and data to every individual human.

Today, the TODA File Protocol has been implemented as a Web integrity network. The integrity network powers issuance, updating and transferring between any system of a new type of unique digital bearer asset, called a TODA file.  TODA files are a new file type that are digitally unique bearer assets (e.g., coins, bills, credentials, and paper documents. TODA files can be controlled, stored, and updated by any empowered system, and can be transferred without need to connect to the issuing system. These qualities strip transaction costs, restore bearer control, and extend the convenience of universal tap and pay of physical store checkout to the online experience.

During 2023, the first version of a working micropayments solution called TAPP (Tapp And Privately Pay) was built by TODAQ Micro which you can find out more about here: https://www.todaq.net. It’s a low code solution allowing any digital content or service to accept micropayments, provide instant paybacks and micro-distributions.  Everyone controls their own assets and records, and best of all anyone can issue any type of asset that can be micro transacted as well.

Rather than explain a brand new tech stack, it seemed easier to just put it into everyone’s hands with an accessible, powerful and fun demo.  So the team went retro. In addition to bringing on sports, media, entertainment, gaming, healthcare, education and AI partners to deploy micropayments, we’re very pleased to release old game with a new twist.

PONG, created in 1972 was one of the earliest video games.  It is available online for free and is largely unchanged from it’s basic 2D form from 52 years ago.  Earlier variations of micropong included a micropong where the form factor reduced the playable game to the size of a penny, and a micropong version that allowed players to control the game through a microphone.  As homage, we thought the natural next step of micropong, was a micropayable release that demonstrated the capabilities of TODA files and TAPP micropayments.  Given the years of work that led to that moment, we had no idea that it would take another 8 months of work to make the transaction dance of micropayments, instant paybacks, micro-distributions, and more flow in just the right way.

This latest version of micropong fuses micropayments, gaming, rewards, and music.   The micropong experience starts when an unknown visitor goes to the micropong  website.  They instantly pay 30 cents, no processing fees, and start a 2 person PVP game. Player 1 also picks a song which will play for both players. Player 1 invites one of their friends to join, who also micropays 30 cents and joins as Player 2. The game session now has 60 cents. They play each other to be the first to 10 points. The winner is instantly paid 40 cents, the music artist is instantly paid 10 cents, and the game treasury gets 10 cents. The music studio that helped produce the chosen song is paid a penny from the artist’s 10 cents.  The audio marketplace that provided beats and samples for the song is paid 2/10th of a penny from the artist’s 10 cents.  Three emerging and ground breaking musicians - Tara Jam, Sean Leon, and Nanu - joined the micropong team so game players could enjoy their music.   Their larger goal was to change the game and show that fair, transparent, and real-time compensation for all artists is possible.

For consumers, these kind of one TAPP micropayments will enable a new complementary option to subscriptions. Non-subscribers can directly micropay for content or micropayable content can be shared by empowered subscribers. For streaming and publishing platforms, this will add revenue streams. It’s not just a consumer thing, platforms can instantly split a single micropayment and distribute to sharers, creators, copyright holders, suppliers, and their staff – removing nearly all back office and processing costs. These frictionless circular payment flows between systems and devices apply to cloud API marketplaces, embedded finance and insurance services, municipalities, e-commerce, and supply chains. New micropayment markets will bring power to creators and consumers, generate new sources of revenue, speed up cash cycles, and greatly reduce back-office costs and liabilities for businesses.

You can try out micropong here:

https://www.todaq.net/story-of-micropong

When Ben Horowitz, co-founder of Andreessen Horowitz wrote The Hard Thing About Hard Things, he provided an invaluable guide to startup management and the challenges of growing a business from scratch.

Within the startup world there is smaller sub-class of ventures called deeptech where there is a whole other complication to deal with as well.

Rather than being driven primarily by innovation, usually with the business model and technical improvements and innovations over what exists today, deeptech ventures are centred around net new invention of technologies that don’t exist and have potential to change the world.

In 2017 when TODAQ was founded the TODA protocol was in its early days. A first whitepaper had been produced and there was a path to produce functioning software that could execute pieces of a new form of ledgerless decentralisation.

The aim was to create a distributed graph data architecture that would allow any data or digital asset to adopt the properties of the physical world, like a piece of paper. Done correctly that would provide a number of benefits, including:

• Unforgeable identity and assets would greatly enhance security and integrity;

• No limits to scale of transactions or assets;

• More powerful ability to create and manage complex, investment-grade, insurable assets;

• Portability of assets and interoperability across any system, blockchain or device;

• True P2P settlement without the need for intermediaries; and

• Greatly improved cost efficiency compared to today’s best-in-class solutions, including removing the need for a settlement gas or token as found in blockchain systems.

By summer of 2019, the first commercial implementation was done, and we created a software API platform called TODA-as-a-Service and executed the first commercial PoCs and projects with it. TaaS worked well and provided improved security guarantees for integrity of assets over what existed in the market and more cost and time savings when settling transactions, but to you had to connect to it to harness TODA, and it was centralised. You couldn’t take the truth of the assets out of the TaaS system.

The much harder work of decentralizing started in early 2020 as COVID hit. There were far more questions than answers at that time, including what would products designed on a decentralised TODA even look like and whether decentralising TODA could even be achieved. For a deep-tech startup this is a terrifying prospect. However there is a saying that is useful during these sort of times. When you’re going through hell, keep going.

Collaboration started with researchers out of the University of Cambridge and University College London and the TODA project turned into four separate but streams of R&D: TODA, ADOT, FEWD and CBDC.

TODA. TODA is a distributed graph data architecture that secures any type of data with a cryptographic data structure called a TODA file to create a unique digital asset. TODA files are digital things that have the qualities of physical things. Transferability. Permanence. Agency. Possession. TODA has achieved the milestone of creating a successful decentralised design with commercialisation starting in 2021. The next phase of work will be preparing the first papers, specifications and shareable for publication and starting open sourcing.

ADOT. An Object Centric Application Protocol that enables software systems to create, interpret, authorise, transmit and transact TODA files between each other without requiring system or data integration. ADOT is a stack of technologies and protocols that work together to make TODA accessible and usable by everyone, everywhere. Limited components of ADOT relevant to building and deploying the first commercial product GOTO have been designed, tested and deployed, but there are several project components still in active R&D.

FEWD. Fair Exchange Without Disputes - Many blockchain systems have atomic swap capability to enable a two way exchange with simultaneous settlement and no escrow agents or brokers, but the assets you can do it with is limited and constrained to within that blockchain system. What is missing is a universal atomic swap solution for everything. Any type or combination of digital assets, including not just TODA Assets like TDN, but also custodial assets, global trade goods, bitcoin, ether, NFTs, twitter accounts, AWS credits, book manuscripts, dog pictures, anything, can be exchanged without relying on an escrow agent.

CBDC. Central Bank Digital Currency. Using ledgerless decentralised technologies such that CBDCs could be designed without facing the tradeoff of either accepting the responsibility of operating a core ledger or ceding control of the CBDC. Thus bringing the qualities of physical cash: (possession, privacy and no fee extraction) to digital money and payment systems.

You can see more background on these projects here and each will be publishing papers and books starting in 2021 and 2022, and establishing the first developer builder community.

After many long months of work the modern design, testing and hammering of a new modern TODA that would enable decentralisation was done and by the winter of 2021 the working software infrastructure and functional demos and PoCs were being coded. Concurrently we started learning from the market the first place to put it into useful action. By summer of this year the GOTO product began coming together.

Apart from commercially shipping product, the next exciting phase of open sourcing will now also begin in stages. We’re grateful to have the first open source leader, Red Hat, along as a partner as this phase begins. Starting next month the first partner technology teams will join the TODA ecosystem to collaborate on specifications and shareable code, and to build TODA enabled systems and apps, as well as convert existing systems to be TODA capable.

Share

Subscribe now

StockFam TV interviewed Sheldon Inwentash, CEO of TODAQ investor ThreeD Capital on TODAQ, the art of pivoting as a startup, bringing a new form of identity solutions to IBM and Red Hat, and the future of the Web 3.0.

Click the link to catch the discussion here:

Disruptive Tech | Discussion W/ Sheldon Inwentash CEO ThreeD Capital

Share

Subscribe now

It was a pleasure for the Capital Club Dubai to host a discussion focused on “CBDCs, Crypto, NFTs – Creating Digital Value" in another episode of Technology Heroes Unplugged.

The topical dialogue on today's asset classes in crypto took place with Hassan Khan, CEO of TODAQ and Dr. Geoffrey Goodell, Senior Researcher at University College London, moderated in an engaging exchange with Naveed Minhas. The conversation focused on the hype and speculation of NFTs that needs to be understood relative to the true value of crypto being a means of value exchange and an emerging asset class.

The discussion further explored Hassan and Geoff’s perspectives across digital value, gold standards, CBDCs features, privacy of crypto usage, ecosystems that crypto helps evolve and macro trends that support crypto. Are NFT’s a bubble or unit of exchange? It concluded with perspectives on monetary policies and the liquidity of crypto versus a timeline to deliver stability for emerging assets.

Catch the discussion here: watch on Youtube or listen on Apple Podcasts.

If you enjoyed this content please subscribe and share:

Subscribe now

Share

TODAQ is pleased to announce they have finalized their agreement with IBM to onboard their software to the IBM Cloud, starting with the Red Hat Marketplace and the OpenShift Platform. The TODAQ team will be working with the IBM and RedHat staff to bring the first specific product to market this fall.

That first low code software product will be focused on empowering developers and companies to be able to adapt their systems and apps with Credential, Identity and Access Management solutions where Credentials and Capability Tokens:

• cannot be forged;

• are self-tracking and hold an internal immutable audit trail;

• update each minute with their own internal unique One-Time-Password and provide the potential to remove steps and weaknesses with today’s passwordless and 2FA solutions;

• become truly portable and interoperable across any system or device; and

• Allow for true P2P verification and transactions without need to connect back to central system to provide offline resilience; and

• Are based on technology efficient and fast enough that verification can practically occur with every use and action, so full Zero Trust.

• Privacy and Need-To-Know. Ensure ownership, control and privacy stay with the true credential owner while giving the verifying counter party the transparency that they need.

Why do we care about empowering customers with these features?

Because the frequency, impact and cost of Cyber Breaches continues to rise and most breaches start with credentials being copied, forged or manipulated.

Because the costs and regulatory burden of proper Verification and meeting Know-Your-Customer requirements continues to rise. This keeps billions of people out of the market, not to mention eating into the margins of businesses. It’s not just financial services where this matters; the growth of marketplaces for digital asset, E-sports and other services is also pushing demand.

Because sovereign ownership of identity and data is not just about human rights, it also makes good business sense, reducing liabilities and costs while allowing for improved provision of goods and services.

Empowering people and businesses to be able to own one set of credentials that can be used anywhere, across any system or device is no longer a nice to have but a transition we must do. Technology alone never solved anything but without a step change in technological capability we will never get there, which is what TODA was designed to solve.

What do we mean when we say credentials and capability tokens?

There are many facets of credentials that point back to an individual or organization and the first TODAQ product will allow any and every one of them to be equipped with these properties.

Capability Tokens give users access rights and privileges with software systems and apps, and there are a number of uses and applications of capability tokens in the market today. The weakness is that the integrity of the capability token is trapped within the system that issued it, so not very portable. We live in a world with tons of systems, with even more interconnections and integrations, so things become complicated, expensive and fragile quite quickly. By providing distributed capability based security, this is a gap TODAQ aims to fix.

Morgan Stanley estimates this as a $40 billion industry that is still nascent with tremendous room for growth. Consider that 80% of this market is just focused on serving the enterprise work forces as the costs and other missing gaps restrict its size and accessibility to everyone.

We look forward to empowering IBM’s customers with some credential superpowers in the near future to solve their business Verification, Fraud, Cost and Automation, as well as Customer Experience needs in the near future. We’re not stopping there, TODAQ Credentials and Access Management product will be available for everyone.

TODAQ is also working with technology partners to provide TODA powered Identity and Biometric Verification Solutions, as well as Data Ownership, Compliance and Privacy Products that will plug and play into into any TODA enabled system.

If you liked this post please share with anyone who may be interested and subscribe to get the latest news.

Share

Subscribe now

TODAQ CEO, Hassan Khan, had the pleasure of being hosted by Stock Fam Group on their YouTube channel for an in depth interview by hosts Sean Khatibi and Graham ‘Hammy’ Skelton on TODAQ and the potential and uses of the ADOT Web and TODA|ADOT technology. Check out the rich discussion here.

Stock Fam Group is an investor awareness and education community with a specific focus on select disruptive technology sectors and companies, and a mantra of “Know what you own”. In addition to the website they are active on Discord, Twitter and Youtube.

Co-Founder Graham Skelton describes the vision as, “The world is evolving around us at a rapid pace and technology is taking us to new places each and every day, including how we invest. As a new investor, or even a veteran investor the flow of information can be challenging to filter. Stock boards are full of vermin and snakes fueled to drive fear and capitalize on greed for personal gain. The goal of the discord investor groups is to reduce the flow of misinformation and weaponize all investors in companies that they love with solid information, DD and a constant stream of information in real time. The power of sharing knowledge and experience in a platform like this is incredible. The more we can help one another to learn, the better off we all will be as investors. As long as we all can share in that same vision, we can all profit together and reduce the effect of those that push misinformation and fear.”

We wish the Stock Fam Group continued success and growth and can definitely connect with the values of hard work, due diligence, authenticity of assets and information, and community (as well as the Oxford comma).

If you enjoyed this content please consider sharing this with others and subscribing to the TODAQ Press!

Share

Subscribe now

Our mid month round up of the latest news from the TODAQ Press.

Projects and Partnerships

TODAQ to talk about the future of containerization and digital assets on the Dave and Gunnar show, with David Egts & Gunnar Hellekson of Red Hat. - READ HERE.

Guest Post: Laurie & Camille from Base Alpha discuss integrated platform solutions for supply chains and exchange markets - READ HERE

Coming up: TODAQ talks TDN digital cash on Gratomic's Youtube channel covering clean, ethical mining of vein graphite for EV batteries - READ HERE

The 2nd part of our Nuclear Power coverage with Beyond Supply Chain: Nuclear Energy & the Hydrogen, Isotopes, Power and Carbon markets - READ HERE

Products and Technology

TODAQ USA to introduce a peer-to-peer Green X Change solution, powered by TDN, to tackle power conservation - READ HERE

Chief Science Officer Dann Toliver discusses the shape of data and the Project MACAW development of an efficient ADOT serialization format - READ HERE

People

TODAQ is pleased to introduce Adam Gravitis our founding CTO, primary co-author of the ADOT Protocol and led the development of TODAQ products - READ HERE

Learning Links

Europe, the GCC and Asia get onboard - Bahrain, Switzerland and Singapore move to give legal ownership standing to digital records and assets - READ HERE

If you enjoyed this content and would like to see more, please subscribe to the TODAQ Press here:

Thank you!

Share

Subscribe now

Bahrain creates history as first nation enacting laws giving legal standing to Electronic Transferable Records from Albawaba Business.

Switzerland issues law giving DLT based securities ownership legal standing from Coindesk.

Singapore introduces Law to give digital trade instruments legal standing from Global Trade Review Publication.

We will frequently share content from customers, partners, technology providers, research collaborators and standards and regulatory thought leaders. Base Alpha was among the first integration and business solutions companies to adopt the TODA/ADOT technologies from TODAQ, and deliver integrated platforms and solutions for clients. Authors Laurie and Camille from the BaseAlpha management team discuss some of their impactful project work across Europe and the GCC and approach to delivering end customer value.

TODAQ Press.

Laurie Fischer, Director Strategy & Risk and Camille Lahoud, CTO Base Alpha

We are a UAE-based technology integrator and digital platform developer with two core business verticals at present. The first focuses on supply chain solutions in the waste management sector, and the second on data platforms to facilitate the exchange of high value, low liquidity assets. We are using TODA/ADOT software products as a fundamental part of our platforms’ backend technology stack.

We’re pleased to announce our first Base Alpha product, integrating a TODA architecture with IoT platforms in a waste management value chain, is in the process of live launch.

Exchanges to facilitate the trade of high-value, low-liquidity assets are in development, with first full commercial launch releases expected later in 2021. We’re looking forward to providing updates in due course.

Base Alpha’s Containerisation Strategy

Whether looking at low value construction waste or high value artwork, the containerisation of digital assets is central to how we think about platform design. The platforms use TODA files as containers for generating and capturing immutable data records, creating the digital twin of the asset they represent. Working with TODA to architect the most efficient and secure file structures, we capture the core data related to a real-world asset in the container’s payload. As the asset progresses through its real-world lifecycle and gets transacted through a supply chain or marketplace, additional data inputs, attributes and histories are added to the container. These additions occur in a range of ways, including the hashing of metadata at the point of transaction and the combining of multiple files with distinct origins into single containers.

The platforms will deliver particular benefits in markets containing a number of disparate actors, processes or systems through which the asset will pass. The TODA architecture allows each of these actors or actions to input data as an independent, authenticated participant in the ecosystem. For example, a high-value artwork could repeatedly change possession and ownership. It will also be subject to multiple external inputs, including valuations, condition reports, restoration or maintenance actions, insurance, transportation and storage. A part of Base Alpha’s value for our customers is to securely and easily allow the substance of each of these interactions to be recorded or input by independent but authenticated actors. This additional information will be stored within the asset’s container and can be traced and verified by interested parties, whether that be auditors or potential buyers, to see who has done what, when and how.

Building the asset’s data stack in this way, with multiple external but validated inputs, contributes to an accumulated proof of integrity and, ultimately, an asset’s value. Liquidity is also improved with the ability to settle transactions with integrity, speed and efficiency built in.

We typically integrate a number of other technology and design features that enhance the power of the platforms. Examples of note include:

• Technology integrations to tie the real-world asset to its digital twin. This can include anything from basic photographs to more sophisticated attribute capture. Hashed as part of the asset’s original file payload, this will enable the digital asset to contain and carry with it a physical fingerprint from its real-world twin.

• An integral data normalisation strategy to allow for targeted data analytics powered by bespoke platform AI/ML modules. These modules can learn from and analyse either the container’s payload itself (for example for image recognition, classification and validation purposes) or data related to transactions and participants on the platform. The latter will power platform ranking and recommendation engines that, through tracking assets and transactions through time, will allow participants to build reputations and expose good or bad performance.

Being Platformists is our identity as a company, and that means platforms that lower costs, increase asset and product values through provable quality and authenticity, and open up previously inaccessible markets and distribution channels for our clients and end users.

Want to speak with Base Alpha? Please reach out here.

If you enjoyed this content and would like to see more, please subscribe to the TODAQ Press and share this post with someone who might appreciate this content.

Thank you!

Share

Subscribe now

It isn’t entirely clear initially what should be included here. The byte layout of a GIF? That doesn’t meet our test of being “mechanically relevant”, meaning something that is important at the protocol level. The layout of an Ed25519 signature? That’s mechanically relevant, but very specific: the parser shouldn’t need to know anything about signature algorithms to do its job of taking bytes off the wire and packaging up their shapes.

How about a list of hashes? That’s a shape that is both mechanically relevant and also at the right level of abstraction. It allows the first stage of interpretation to proceed without needing to know the gnarly details of byte configurations for arbitrary blobs, while still giving it enough structure to handle making requests for more information and linking together data as it is received.

What about specific lists of hashes, perhaps ones that are mechanically relevant? Is it enough to have a single generic list of hashes, or does that need to be special-cased to make specific shapes in cases where the hashes in the list have mechanically relevant interpretations? The right answer seems to include a certain amount of polymorphism, where the generic list of hashes represents a fully parametrically polymorphic list type (including heterogenous lists, no less), and the specializations are themselves parametrized over equivalence classes of shapes. This yields a good blend of power and flexibility while fitting into a convenient byte-sized wrapper, and makes the macaws happy.

— Dann