TL;DR: Stablecoins made it possible to move familiar fiat units across blockchain networks, but the next stage of digital money goes beyond moving value from A to B. Programmable transactions can attach conditions covering identity, compliance, delivery, collateral, tax, escrow, and settlement to the movement of money itself. As finance becomes more automated, money may increasingly be a component of a larger piece of software.

Key takeaways:

Stablecoins solved an important problem. They made it possible to move familiar units, like dollars, across blockchain networks without incurring the price volatility associated with digital currencies like BTC or ETH. Today, dollar-backed stablecoins such as USDT and USDC can move around the clock and interact directly with blockchain applications.

The model has been extremely successful. According to the Bank for International Settlements (BIS), 99.4% of fiat-backed stablecoins by market value are pegged to the US dollar.

However, putting dollars on digital rails doesn’t fundamentally change what a dollar is. The next stage will be about changing what can happen when the money moves.

Stablecoins put existing money on new rails

At its simplest, a stablecoin payment expresses a familiar instruction.

Send $100 from A to B.

The technology underneath the payment may be different, but the economic action is much the same as sending $100 through a conventional payment system.

Programmable transactions can add another layer. Some examples of instructions include: send $100 to B only after the goods have arrived; release payment once both parties have signed; pay the seller once the buyer’s identity has been verified; or release collateral when a loan is repaid.

In each case, the money itself may still represent the same $100. The logic governing when and how it moves is what changes.

Stablecoins are already programmable to an extent. The BIS describes them as tokens on programmable ledgers that can be integrated with smart contracts, while recent BIS research found that stablecoin transfers are frequently embedded inside more complex transactions involving trading, lending, liquidity provision, and settlement.

Therefore, the next step isn’t necessarily replacing stablecoins with a new form of programmable currency, but making the transaction itself more programmable.

Back to the top ↑

The payment can become part of the process itself

Think about an international shipment.

Today, one system typically contains the purchase order, another tracks the goods, a bank handles the payment, an insurer covers the shipment, and customs authorities collect duties. Each party records its own part of the transaction, and several systems may need to be reconciled before everything is complete. This will become even more complex in the age of agentic commerce.

Programmable finance can bring some of these events together. For example, delivery could be verified, payment released, ownership transferred, and other contractual conditions updated as part of the same process.

The International Monetary Fund (IMF) describes programmability as one of the main features of tokenized finance. Smart contracts can automatically execute financial logic, including margin calls, interest payments, and collateral transfers, while shared ledgers can reduce the need for separate institutions to reconcile their own records.

Project Agorá is a real-world example of this. This BIS-led project combines tokenized commercial bank deposits with tokenized central bank reserves on a shared programmable platform. Smart contracts can embed workflow logic, compliance requirements, and conditional payment triggers directly into transactions.

As a result, the payment stops being something that happens at the end of a process and becomes part of the process itself.

Back to the top ↑

Programmable money doesn’t have to mean programmable currency

The phrase “programmable money” can imply that the currency itself contains rules restricting what its owner can buy, where it can be spent, or when it expires.

That is one possible design, but it isn’t the only way to make payments programmable. A dollar, euro, stablecoin, tokenized bank deposit, or central bank digital currency (CBDC) can remain a fungible monetary unit while smart contracts and other infrastructure determine the conditions surrounding a particular transaction. In other words, the money can remain money while the transaction becomes software.

This means several forms of digital money could coexist inside the same programmable economy. Stablecoins can operate on public blockchains; tokenized deposits can represent claims against commercial banks on programmable ledgers; and both wholesale CBDCs and tokenized central bank reserves can provide settlement money between financial institutions.

The BIS defines tokenized deposits as commercial bank deposits represented on programmable or tokenized ledgers, and projects such as Agorá are already testing how commercial bank money and central bank money can interact on shared programmable infrastructure.

Therefore, the important question may be less about which form of digital money replaces the others and more about whether they can interact inside the same financial processes.

Back to the top ↑

More programmability also means more things can go wrong

Attaching more logic to transactions creates obvious advantages but also introduces new risks. Payment may depend on delivery data that turns out to be wrong, identity systems can fail, and tax, collateral, or compliance rules may need to be updated when laws change.

The more logic built into the transaction, the more the system depends on accurate data, reliable infrastructure, and strong guardrails. Processes that once involved human intervention can execute automatically, meaning failures may also propagate faster.

This means programmable finance doesn’t eliminate the need for governance, but it does change where some of that governance happens. Rules need to be written correctly, external information needs to be reliable, and there need to be mechanisms for dealing with errors, disputes, legal changes, and unexpected events. There is also an important design question over how much logic should be attached to money itself and how much should sit around it.

A broadly fungible monetary unit has obvious advantages. Instead of changing the behavior of the dollar itself, programmable infrastructure can apply rules to a particular transaction while leaving the underlying money unchanged.

Back to the top ↑

Programmable finance creates an infrastructure problem

A simple payment might involve a single transfer, but a programmable transaction can involve multiple connected events.

Identity may be checked, payment released, ownership transferred, collateral updated, compliance recorded, and a receipt generated as part of the same economic action.

This is already visible in stablecoin activity. A 2026 BIS study analyzed 141 million Ethereum transactions involving USDT, USDC, and PYUSD and found that roughly one-third generated multiple steps. Nearly 60% of stablecoin transfer events occurred inside complex transactions rather than simple standalone payments. As programmable finance expands, these interactions could become much more common.

Add AI agents capable of initiating payments, trading assets, moving collateral, and purchasing services automatically, and the number of machine-generated financial events could increase significantly.

Interoperability then becomes essential because the identity system, bank, asset ledger, stablecoin, logistics provider, and compliance service may all operate on different infrastructure.

Scale matters for the same reason. A scalable public blockchain can act as the shared transaction layer underneath these systems, allowing payments and other state changes to be recorded and referenced without requiring every participant to maintain an isolated version of the same event.

Once again, not every rule or piece of private data needs to reside directly on a public blockchain—private databases can be linked to it via cryptographic hashes. However, if programmable finance eventually involves millions of assets, machines, and conditional transactions, the underlying infrastructure needs to process huge numbers of events quickly and affordably.

Stablecoins changed how money moves, but programmable finance goes further by changing what can happen as it moves.

Back to the top ↑

FAQs:

What is programmable money?
Programmable money refers to digital money or payment infrastructure that can interact with software rules determining when, where, or under what conditions a transaction occurs.

Are stablecoins already programmable?
Yes. Stablecoins can interact with smart contracts and already form part of complex programmable transactions involving trading, lending, settlement, and other financial activities.

What is the difference between programmable money and programmable payments?
Programmable money can imply that rules are attached to the digital currency itself. Programmable payments can leave the underlying monetary unit unchanged while applying conditions to a specific transaction.

Can bank deposits and CBDCs be programmable?
Yes. Tokenized bank deposits can operate on programmable ledgers, while central banks are testing tokenized reserves and wholesale CBDC infrastructure that can interact with smart contracts and tokenized assets.

Why does scalability matter for programmable finance?
A programmable payment can trigger several other actions, including identity checks, asset transfers, collateral updates, and compliance events. At large scale, this creates far more transactions and state changes than simple payments alone.

Watch: Peer-to-peer electronic cash system—that’s micropayments

Advertisement
Advertisement