Axel Quack
In the architecture of modern financial infrastructure, the evolution toward programmable central bank digital currencies (CBDCs) marks a pivotal shift from static ledgers to dynamic, self-executing systems. These tokens are not merely digitized fiat but programmable objects capable of enforcing rules, responding to conditions, and integrating with autonomous agents to facilitate seamless, compliant value transfer. With the European Central Bank's digital euro in its preparation phase and global pilots advancing under frameworks like the BIS Unified Ledger, the focus is on designs that balance scalability, privacy, and regulatory resilience. This article explores the technical foundations of these systems, emphasizing how they enable agentic settlement in regulated industries such as financial services and insurance. By examining core models, enforcement mechanisms, and AI integration, we uncover how programmable tokens create a sovereign layer that stabilizes flows without sacrificing efficiency.
Architectural Overview: The Move to Object-Oriented Money
The foundational change in advanced CBDC designs—exemplified by the ECB's N€XT prototype (PDF) and the BIS's Unified Ledger concept—is the departure from traditional account-based models to unspent transaction output (UTXO) paradigms. In an account-based system, value resides in mutable balances tied to a global state ledger, where every transfer requires locking and updating shared rows, leading to contention in high-concurrency environments. UTXO models, by contrast, treat money as discrete, immutable objects: each token is an independent UTXO with its own embedded metadata and execution logic, allowing parallel processing without state conflicts. This object-oriented approach is essential for programmability, as it permits tokens to carry self-contained rules—such as conditional spending or expiry clauses—without relying on external state queries.
Source: Bitcoin Transactions Explained: Understanding the UTXO Model by CodeLucky
The N€XT engine, central to the ECB's digital euro vision, implements this through a sharded microservices architecture optimized for the Eurozone's transaction volume. Sharding partitions the ledger by key ranges (e.g., hashed wallet identifiers), enabling independent validation: a retail payment in Shard A settles concurrently with a wholesale atomic swap in Shard B, eliminating bottlenecks. Consensus relies on deterministic finality protocols rather than probabilistic mechanisms, ensuring settlement in under one second for wholesale operations and near-instant confirmation for retail. Throughput scales to millions of TPS (transaction per second) via horizontal node expansion, with geo-redundant deployments—leveraging low-latency interconnects and renewable energy sites—to meet DORA resilience standards. This design supports the dual-layer structure of retail (high-volume, privacy-focused) and wholesale (interbank, programmable) CBDCs, where tokens in the wholesale layer can represent tokenized reserves or collateral, settling cross-border flows atomically.
The N€XT Settlement Engine: A Deep Dive
At the heart of N€XT is a UTXO model tailored for parallelism and programmability, diverging from Bitcoin's decentralized variant by prioritizing controlled environments over open consensus. In practice, when a user initiates a transfer, the engine identifies the relevant UTXO (e.g., a €50 token with embedded metadata for spending limits) and locks only that object, not the entire wallet state. The transaction script— a compact bytecode payload—executes locally on the validation node, evaluating conditions like merchant category restrictions or time-based vesting before broadcasting the new UTXO set. This minimizes contention, allowing the system to handle Eurozone-scale volumes: retail micropayments process at sub-millisecond latencies on edge nodes, while wholesale batches aggregate for efficiency.
Sharding further enhances this: the ledger divides into logical partitions based on cryptographic hashes of token IDs, with cross-shard communication handled by lightweight commit protocols. Microservices decompose the engine into specialized components—a token validation service for opcode execution, an oracle aggregator for external data, and a privacy mixer for anonymization—communicating via e.g. gRPC over encrypted channels. Latency benchmarks from the ECB's October 2025 report show wholesale finality under 1 second (p99), with retail offline reconciliation syncing in 200–500 ms upon reconnection. The engine's resilience incorporates DORA-compliant failover: redundant nodes automatically assume primary roles during outages, maintaining >99.99% uptime through automated health checks and circuit breakers.
The "Waterfall" and "Reverse Waterfall" Mechanisms
A hallmark of sovereign programmability is the holding limit—proposed at €3,000 per individual in ECB models—to prevent bank disintermediation while enabling seamless liquidity management. This is enforced through the Waterfall mechanism, a token-level rule that automatically redistributes excess holdings.
In the Waterfall (defunding flow), if an incoming payment pushes a wallet above the limit, the token's embedded script triggers a smart routing instruction. The excess UTXO "spills over" via an atomic operation: the engine mints a new transfer to the user's linked commercial account, executed as a SEPA Instant Credit Transfer with finality in 10 seconds. This is not a post-transaction adjustment but a pre-commit validation—the opcode halts the initial settlement until the spillover completes, ensuring balance neutrality. The Reverse Waterfall (funding flow) mirrors this for insufficient holdings: attempting a €50 payment with €20 in CBDC invokes a pull from the commercial account, minting the shortfall as a new UTXO in an atomic bundle. Both mechanisms rely on tokenized instructions—JSON-encoded payloads with merchant whitelists or rate limits—processed by the validation service without user intervention.
The Role of Agentic AI in Sovereign Settlement
Programmable tokens provide the viscous rules (limits, triggers), but agentic AI delivers the conductance, navigating these constraints with predictive intelligence. In N€XT-like systems, AI agents—deployed in wallets or payment service provider clouds—could act as the interface for complex transfers, optimizing liquidity and compliance in real-time.
The "Liquidity Manager" Agent
The Liquidity Manager is an autonomous agent that proactively maintains optimal CBDC balances, minimizing waterfall latency. It analyzes spending vectors from historical UTXO patterns and external signals (e.g., calendar events or merchant APIs), predicting outflows with 85–95% accuracy in production models. For a high-value purchase like a train ticket, the agent pre-emptively pulls funds from the commercial account, minting fresh UTXOs before the user initiates the transaction—ensuring instant settlement without ad-hoc delays. In waterfall optimization, the agent routes incoming micropayments directly to tokenized instruments (e.g., money market funds) if the wallet nears the cap, bypassing zero-interest checking via conditional opcodes. This agentic layer reduces average transaction latency by 40–60% in simulations, integrating with RAG pipelines to retrieve contextual data like seasonal spending trends.
The "Compliance Node" Agent
Compliance Agents transform static AML rules into dynamic evaluators, attaching cryptographic validity tokens to transactions. Upon mempool entry, the agent parses metadata—UTXO history, geolocation hashes, velocity metrics—and computes a risk score using graph neural networks on tokenized flows. For scores above 0.8, it injects an opcode requiring step-up authentication (biometric ZK-proofs or selective disclosure), halting execution until verified. The validity token—a PS256-signed JWT bound to the agent's identity—travels with the transaction, enabling audit trails without exposing sensitive data. In cross-border scenarios, these agents coordinate via BIS-like orchestration layers, ensuring MiFID II alignment for derivatives-linked tokens.
The Cryptographic Layer: Privacy & Zero-Knowledge Proofs
Tiered anonymity balances privacy with AML under GDPR. Offline protocols use secure elements for NFC peer-to-peer, storing signed "Offline UTXOs" that sync upon reconnection with double-spend proofs. Online, pseudonymized hashes obscure mappings (Hash_A to Hash_B visible, but not to identities without court-ordered keys). zk-SNARKs prove compliance succinctly, while HE aggregates statistics on ciphertext.
Source: zk-SNARKs Explained by Binance
Technical Use Cases in Regulated Industries
In financial services, autonomous KYC agents query insight tokens for dynamic lending, minting restricted UTXOs spendable only at whitelisted merchants. For insurance, parametric payouts use oracle agents to trigger escrows on flood events, settling atomically. Payments reconciliation agents match SEPA XML with CBDC streams, minting deposits via ISO 20022 mappings. Supply chain escrows release on IoT-signed deliveries, with temperature breaches auto-refunding penalties. EMEA-specific pilots test welfare vouchers with TTL and merchant restrictions, while Hong Kong's e-HKD explores proxy re-encryption for privacy-enhanced retail triggers. In further detail:
Financial Services – Autonomous KYC & Dynamic Lending
A corporate treasury or SME requests an instant liquidity line. The bank’s Risk Agent queries the applicant’s Insight Token (a privacy-preserving vectorised cash-flow history derived from past UTXOs). If real-time cash-flow variance is below 5 %, the agent auto-approves and mints a Restricted Credit Token on the CBDC ledger. This token carries an embedded opcode (OP_VERIFY_VENDOR) that cryptographically enforces spending only at pre-approved supplier wallets (identified by merchant category codes or public-key whitelists). The borrower cannot divert the funds into speculative assets or unrelated expenses; the token simply refuses to move unless the counterparty matches the whitelist. Settlement is atomic, final in <1 second on the wholesale layer, and fully auditable under Basel IV without exposing the underlying transaction graph.
Insurance – Parametric Payouts via Oracle Agents
A logistics company holds parametric flood cover. The policy premium is escrowed as a programmable CBDC token in a smart-contract UTXO. A dedicated Weather Oracle Agent continuously monitors Copernicus Sentinel-1 satellite radar data for the insured coordinates. When water depth exceeds 30 cm for >6 hours, the oracle signs a cryptographic attestation with its private key. The escrow contract verifies the signature against the oracle’s registered public key and instantly releases the full payout amount to the insured’s wallet. No claims adjuster, no manual verification, no delay. The entire flow (detection → attestation → release) completes in under 4 seconds in the latest BIS/HKMA pilot results.
Payments – Multi-Rail Reconciliation Agents & ISO 20022 Bridging
Legacy SEPA Instant and SWIFT GPI messages arrive in XML-based camt.053/camt.054 formats, while the CBDC layer operates on native UTXO streams. A Reconciliation Agent sits between the two worlds: it parses the unstructured RemittanceInformation field in the SEPA XML, extracts the EndToEndId, and matches it against pending CBDC UTXOs using fuzzy pattern-matching and graph neural networks. Once a match is confirmed, the agent triggers a Mint instruction on the CBDC ledger, creating the corresponding tokenized deposit with full ISO 20022 payload mapping (pain.001 → pacs.008 → custom CBDC extensions). The result is real-time, fully reconciled balances across old and new rails, with zero manual intervention and audit trails that satisfy both PSD3 reporting and DORA resilience requirements.
Supply Chain Finance – IoT-Signed Escrow Tokens
Based directly on Project Acacia patterns: a buyer locks funds in a Delivery Escrow UTXO. The physical container is equipped with an IoT hardware oracle (GPS + temperature sensor) running a lightweight secure element. Upon arrival, the device checks that GPS coordinates match the bill-of-lading destination and that temperature stayed below –18 °C throughout the journey. If both conditions are met, the IoT module signs a release transaction with its device-bound private key. The escrow contract verifies the signature chain (device → manufacturer → accredited oracle registry) and instantly releases payment to the supplier. If temperature breached the threshold, the contract automatically refunds a pre-agreed penalty percentage to the buyer and routes the remainder to the supplier. The entire settlement is atomic, on-chain, and completes in <1 second on the wholesale layer.
EMEA-Specific – Programmable Welfare & Social Payments
In more "Visionary" workstreams and various national pilots, governments issue conditional welfare tokens. A heating allowance, for example, is minted as a time-bound UTXO with two embedded opcodes:
OP_CHECK_TTL(expires after 31 March)OP_VERIFY_MCC(only accepted by merchants in the utility/heating-oil category)
When a citizen attempts to spend the token at a supermarket, the point-of-sale agent submits the transaction; the token’s own script evaluates the merchant category code and returns FALSE at the protocol level, rejecting the payment before it ever hits the ledger. No central blacklist, no privacy leak—just sovereign viscosity encoded directly into the money.
Hong Kong e-HKD – Privacy-Enhanced Retail Triggers via Proxy Re-Encryption
Phase 2 of the e-HKD pilot (October 2025 report) introduced proxy re-encryption for retail escrow use cases (e.g., gym memberships, tuition fees). The consumer escrows funds in a programmable token that releases monthly tranches. Instead of the gym logging "Member X visited", the turnstile’s IoT device generates a zero-knowledge proof ("a valid member used the service today") and sends it to a Settlement Agent. The agent uses proxy re-encryption keys to transform the ciphertext so that only the escrow contract can decrypt the usage attestation, releasing exactly 1/12th of the funds. The ledger records the payout but never learns which member attended, achieving perfect forward privacy while still enforcing the trigger condition.
Source: A Retail CBDC in Hong Kong. Lessons Learned from e-HKD Pilot Programme
These six patterns are not theoretical; they are either live in controlled pilots or have been fully demonstrated in BIS, ECB, and HKMA test environments by the end of 2025. They represent the moment when programmable sovereign money becomes truly agentic—where the token itself carries the policy, the agent carries the intelligence, and settlement becomes instantaneous, auditable, and sovereign by design.
Final Thoughts
Programmable CBDC tokens are the sovereign foundation on which tomorrow’s agentic financial system will run. The UTXO object model, sharded N€XT engine, waterfall liquidity mechanics, zk-SNARK privacy, oracle-triggered opcodes, and DORA-grade resilience already exist in live pilots. Together they turn money into a self-executing, policy-carrying object that can enforce holding limits, merchant restrictions, parametric payouts, and atomic cross-border settlement—all in under one second on wholesale rails and with offline retail capability.
Most crucially, these tokens are built to be consumed by autonomous AI agents: Liquidity Managers that pre-fund wallets, Compliance Nodes that attach validity tokens, Reconciliation Agents that bridge SEPA/SWIFT to ISO 20022, and Oracle Agents that release escrows on real-world events. The six patterns we examined—restricted credit tokens, parametric insurance, multi-rail reconciliation, IoT-signed supply-chain escrows, conditional welfare vouchers, and proxy-re-encrypted retail triggers—are not future concepts; they are demonstrated today in ECB, BIS, and HKMA test environments.
This is sovereign money that no longer merely moves—it reasons, restricts, and releases according to embedded policy, while remaining fully open to the agentic commerce stacks that are already shipping at global scale. The fusion is inevitable, and when it arrives, the line between "programmable" and "agentic" money will disappear. Europe is not just preparing for this future; it is building its technical bedrock right now.
Part 2 will examine how the private-sector agentic commerce stacks (Mastercard Agent Pay, Visa Intelligent Tokens, Stripe ACP) are already consuming similar primitives at global scale—often with lower latency and broader merchant acceptance than today’s CBDC pilots.
The website and the information contained therein are not intended to be a source of advice or credit analysis with respect to the material presented, and the information and/or documents contained on this website do not constitute investment advice.
Addendum: Yes, I do leverage AI to compile these articles. Over the past 16 years, I have been collecting my research in Markdown format—now totaling over 3,200 documents—archived in Obsidian. I run Open WebUI and Ollama for my local LLMs on a Talos OS Kubernetes Cluster, and use LiteLLM to integrate public LLMs. I also leverage Readwise to auto-store interesting tidbits in Markdown and my local RAG, plus run multiple agents to compile compelling data pieces.