Working flows, not mockups.
Agent payments are the first step. The deeper demo path is programmable credit: bounded Notes, policy limits, work verification and settlement receipts on Ergo testnet.
Accord demo tracks
Payment, tools, APIs and credit.
These pages describe the runnable flow targets before the live event stream is wired. Mock mode comes first; testnet mode is added only when sources and receipts are reproducible.
Agent buys API call
One call. One proof. No persistent account.
An autonomous agent creates a note, sends it to an API provider. The provider validates the acceptance predicate on-chain and delivers the response. No API keys, no billing accounts, no Stripe.
Step-by-step
- 1Agent creates a note (0.001 ERG face value)
- 2Note contains: provider address + task hash + deadline
- 3Provider checks predicate — verified on Ergo testnet
- 4Provider delivers API response
- 5Note burned, ERG released to provider
Why this matters
This is the atomic unit of agent commerce: one task, one payment, one proof. No identity required.
// Install: npm install @fleet-sdk/core
// Pseudo-code — illustrates the shape of a Note creation. Production
// usage pins the exact Ergo-compatible hash function and the canonical
// audited script address; do not deploy this snippet as-is.
import { TransactionBuilder, OutputBuilder } from "@fleet-sdk/core"
import { blake2b256 } from "@fleet-sdk/crypto"
// Create a payment note for one API call
const noteBox = new OutputBuilder(
1_000_000n, // 0.001 ERG
NOTE_CONTRACT_ADDRESS
).setAdditionalRegisters({
R4: SGroupElement(providerPublicKey), // who receives
R5: SLong(BigInt(currentHeight + 100)), // deadline
R6: SColl(SByte, blake2b256(taskDescription)), // task proof — Ergo-native hash
})
const tx = new TransactionBuilder(currentHeight)
.from(myInputs)
.to(noteBox)
.sendChangeTo(myAddress)
.payMinFee()
.build()Agent issues credit to sub-agent
Reserve deployed. Bounded Notes issued. Tracker monitors.
A parent agent creates a policy-constrained budget without handing over a private key. Notes are issued against a reserve, spent by a sub-agent, verified by task rules, and redeemed only under explicit settlement constraints.
Step-by-step
- 1Reserve contract deployed with 10 ERG + 100 ERG credit limit
- 2Bounded Notes issued against reserve (up to limit)
- 3Sub-agent transfers Notes to providers as task-conditioned credit
- 4Tracker updates cumulative balance on-chain
- 5Redemption happens only after verification rules are satisfied
Why this matters
Verifiable workflows make payment trustworthy. Programmable credit lets agents coordinate future work before final settlement.
// Deploy a reserve with credit limit
const reserveBox = new OutputBuilder(
10_000_000_000n, // 10 ERG collateral
RESERVE_CONTRACT_ADDRESS
).setAdditionalRegisters({
R4: SLong(100_000_000_000n), // 100 ERG credit limit
R5: SLong(0n), // total issued so far
R6: SGroupElement(controllerKey),
})
// Notes are issued from this reserve
// Tracker enforces: issued <= credit_limit
// Settlement happens when tracker triggers thresholdCommunity reserve + tracker
A local marketplace. A compute co-op. An agent network.
A group of participants pool ERG into a shared reserve. Community notes are issued proportionally. Acceptance predicates define membership rules. Members can redeem notes for ERG at any time from the reserve.
Step-by-step
- 1Community members pool ERG into multi-sig reserve
- 2Members receive community notes proportional to contribution
- 3Notes accepted within community per acceptance rules
- 4Any member can redeem notes for ERG anytime
- 5Tracker provides public auditability of flows
Why this matters
This is the most general form: a programmable local economy. Could be a marketplace, a DAO treasury, or an agent cooperative.
// Multi-sig community reserve
const communityReserve = new OutputBuilder(
TOTAL_POOLED_ERG,
MULTISIG_RESERVE_ADDRESS
).setAdditionalRegisters({
R4: SColl(SGroupElement, memberKeys), // 5 members
R5: SInt(3), // 3-of-5 to redeem
R6: SColl(SByte, communityTokenId), // community token
})
// Acceptance predicate — members only:
// { val isMember = memberKeys.exists(pk => proveDlog(pk))
// sigmaProp(isMember) }Open Problems
What's still unsolved
These are the most interesting open problems in agent money. If any of these resonate — we want to hear from you.
Agent identity without persistent accounts
How do agents build reputation across sessions without deanonymisation?
Note acceptance UX for non-technical agents
SDK-level abstraction so LLM agents can issue and accept notes with minimal setup.
Tracker federation across reserves
Cross-reserve accounting and liquidity — can notes be accepted across different community reserves?
Agent reputation without centralized oracle
Verifiable reputation score derived from on-chain history, no trusted third party.
Local community wallet — one-click deploy
Spin up a community reserve, issue tokens, and configure acceptance rules in under 5 minutes.
Generate your first agent payment
Paste your Ergo testnet address. We fetch your live UTxOs and generate a ready-to-run Fleet SDK script — pre-filled with your actual data.
Need testnet ERG? testnet.ergofaucet.org — free testnet ERG in seconds.
Address balance lookup
Query any Ergo address balance live from the blockchain. Real data, real network.
Data fetched live from api.ergoplatform.com