Most agent payment systems begin once a transaction is already expected.
A service has been requested. A checkout has started. A payment instruction is waiting to be authorized. TLAY starts one step earlier: should this machine transact at all?
In our live demo, an Arkreen eCandle makes an energy service available and broadcasts a changing price. A Bitaxe miner evaluates that offer against its own economics every 10 seconds.
It can accept. It can wait. It can refuse. Only when the conditions make sense does the machine authorize a USDC payment on-device, settle on Arc Testnet and consume the service. Service discovery, price negotiation and evaluation, transaction decision, authorization and service delivery all happen in the local machine loop.
The important result is not simply that the machine can pay. It is that the machine can decide not to. That is the difference between payment automation and economic agency.
Payment automation is not economic agency
Programmable payment rails answer a necessary question: once an agent wants a paid resource, how can it pay securely and receive it?
TLAY focuses on the question before payment: what makes the transaction worth doing in the first place?
Economic agency begins earlier. A machine must discover an available service, interpret or negotiate its price, evaluate that price against local conditions, and decide whether the exchange should happen at all.
The local machine economy loop is:
- discover an available service;
- negotiate and evaluate the price;
- decide whether to transact — or decline;
- authorize payment on-device; and
- settle and receive the service.
Payment is not the starting command. It is the output of a bounded local decision. TLAY is building the embedded wallet and trust infrastructure that lets machines determine when a compatible payment rail should be used.
The most important transaction may be the one the machine decides not to make.
How the demo works
The setup connects three visible components — the energy device, the buyer and the dashboard — while keeping the discovery, price evaluation, transaction decision and authorization loop with the machines.
1. The eCandle publishes an energy service and price
Arkreen’s eCandle represents the physical energy side of the exchange. It makes an energy service discoverable and broadcasts a live electricity price that changes over time, turning a real-world condition into a signal another machine can evaluate.
2. The Bitaxe evaluates the economics locally
Every 10 seconds, the Bitaxe miner compares the current electricity price with its own mining economics and local policy.
This is an evaluation interval, not an unconditional payment interval. If the price does not make economic sense, the device waits and no payment request is made. The ability to decline is part of the transaction logic, not an exception handled by a human.
3. The device authorizes payment
When the economics are favorable, the Bitaxe signs a USDC payment authorization on-device. The wallet and payment decision sit with the machine instead of being delegated to a custodial server holding funds on its behalf. That distinction matters. The machine is not merely executing a payment instruction generated somewhere else. It is acting on a decision formed locally within explicit policy boundaries.
4. USDC settles on Arc Testnet and the service is delivered
The payment moves through Circle’s infrastructure and settles on Arc Testnet. The dashboard makes the loop visible: service and price discovery, local evaluation, transaction decision, authorization, settlement and service delivery.
The local machine economy loop
Discover → Negotiate → Evaluate → Decide or decline → Authorize → Settle → Receive service
Why nanopayments change the infrastructure requirements
The term nanopayment is useful here because the defining constraint is not only value. It is the combination of small transaction size, high decision frequency and machine-native execution.
At that scale, familiar inefficiencies become architectural blockers.
Settlement must keep pace with the decision loop
If confirmation takes longer than the interval between decisions, transactions can queue up and the machine loses a clear view of its current economic state. Arc’s sub-second deterministic finality allows a transaction to settle before the next evaluation begins.
Transaction costs must remain predictable
A small payment cannot depend on a volatile gas asset whose cost may exceed the value being transferred. On Arc, gas is denominated in USDC, aligning the transaction fee with the settlement asset and making costs easier for machines to model.
The asset layer must be programmable
Today, the devices in the demo transact in USDC. Future machines may also need to manage collateral, move liquidity across networks, pay for data, access credit or coordinate with other automated services. A stablecoin-native, composable settlement environment gives builders room to extend the pattern without replacing the underlying payment architecture.
Why the wallet belongs on the device
The important result is not simply that software can initiate a transaction. That has been possible for years.
The important result is that the machine can hold value and make a bounded economic decision itself — including the decision not to transact.
Putting the wallet and authorization logic on the device creates a clearer trust model:
The device does not need a remote custodian to hold its operating balance;
The payment decision can be tied directly to local conditions;
Authorization policies can be constrained by price, amount, counterparty or time; and
A device can continue operating as part of a machine network rather than a human checkout flow.
Embedded wallets are therefore not a smaller version of consumer wallets. They are control infrastructure for autonomous economic activity.
From a tabletop demo to real machine markets
The eCandle and Bitaxe demonstrate the smallest complete version of the pattern: one machine makes a service available, another discovers and evaluates it, and payment closes the loop only when the exchange makes economic sense.
The same architecture can extend to:
an electric vehicle negotiating and paying a charging point;
a sensor purchasing data relay from a neighboring gateway;
an edge device buying compute only when local demand justifies it;
manufacturing equipment purchasing machine time or a consumable input; and
distributed energy resources responding to real-time prices.
Across these examples, the shared requirements are consistent: local service discovery, interpretable price signals, embedded value, bounded decision logic and continuous settlement.
What we learned
Making the loop physical exposed details that are easy to ignore in a cloud-only prototype.
The price signal has to be timely and interpretable. The device needs a reliable policy for when not to transact. Wallet security cannot depend on a human interface. Settlement state must be observable. And the cost of each action must remain proportionate to the value exchanged.
Those constraints are exactly why we built the demo with real hardware. A machine economy will not be defined only by agents that can call payment APIs. It will be defined by devices and agents that can discover, evaluate, decide — and safely decline — as local economic participants.
Build the next machine payment loop
The Arc Builder Spotlight showed one energy-to-compute exchange, but the architectural idea is broader: machines should be able to form bounded economic intent at the edge, then invoke a compatible payment rail when local conditions justify it.
If you are building connected hardware, AI agents, energy systems, data networks or autonomous services, start with three questions:
- What does the machine produce or consume?
- What signal or negotiated condition should determine whether it transacts?
- How frequently must it decide and settle?
TLAY is building the embedded wallet and local trust layer for this model. It does not replace payment rails; it lets machines decide when those rails should be used.
Payment is the result — not the command.
Next Steps
Read the Arc showcase: https://www.arc.io/blog/how-tlay-is-building-the-payment-layer-for-the-machine-economy
Build with TLAY: https://tlay.io
Explore Arkreen and eCandle: https://ecandle.arkreen.com