If you've watched the agent-payments space over the last few months, you've seen two settlement models harden into place, and they are not the same thing wearing different names. One is custodial escrow with dispute resolution. The other is trustless atomic settlement. Most of the noise treats them as interchangeable "settlement layers." They aren't. They solve different problems, they fail in different ways, and they cost different things. This post is an attempt to lay the tradeoffs out honestly - including where atomic settlement is the worse choice - so you can reason about which one ends up underneath autonomous agents.
Two models, stated plainly
Escrow + dispute resolution. A trusted party (or a contract acting as one) takes custody of one or both legs of a trade, holds them, and releases according to rules. If something goes wrong, an arbiter adjudicates. This is the model most agent payment rails are converging on, and it's the model a major exchange shipped recently in its agent payments protocol: quote โ negotiate โ escrow โ settle โ dispute.
Atomic settlement. No one takes custody. Both legs are locked against a shared cryptographic secret. Revealing the secret clears both legs simultaneously; if the secret is never revealed, a timeout refunds both sides. The canonical primitive here is the hashed timelock contract (HTLC): funds are locked behind hashlock = H(secret) plus a timelock, and the only two terminal states are "both legs settled" or "both legs refunded."
The one-sentence difference: escrow asks you to trust that the holder behaves; atomic settlement removes the holder.
What escrow gets right (the honest case for it)
It would be dishonest to wave escrow away. It has real advantages, and pretending otherwise is how you lose technical readers:
- It ships today and it's legible. Escrow maps onto how commerce already works. Product, ops, and legal teams understand "funds held, then released."
- No liveness assumption on the counterparty. Atomic swaps need both parties (or their agents) to be online to complete the reveal within the timeout window. Escrow doesn't - the custodian is the always-on party.
- No capital locked waiting on a secret. In an HTLC, your funds sit locked for the duration of the timeout. That's an opportunity cost, and for high-frequency agent flows it's a real one.
- A human can intervene. When a trade is genuinely ambiguous - wrong item, fraud, a bug - an arbiter can untangle it. Pure atomicity has no "undo."
If you're optimizing for time-to-market and human-recoverable failure modes, escrow is a reasonable answer.
What escrow can't do
Here's the structural limit. Escrow answers exactly one question: "will my money be held safely?" It never answers the other one: "who am I actually trading with?" A custodian can hold funds flawlessly and still release them to a counterparty that misrepresented itself. Custody integrity and counterparty integrity are different problems, and escrow only touches the first.
And escrow reintroduces the precise thing autonomous agents were supposed to eliminate: a trusted middle. A middle that can be hacked, frozen, subpoenaed, or simply go offline. Every "escrow agent" is a honeypot proportional to the value flowing through it. The more the agent economy scales, the larger that honeypot grows. Dispute resolution is downstream evidence of this: if settlement were atomic, there would be nothing to escrow and nothing to dispute, because both legs clear or neither does.
What atomic settlement costs (the honest case against it)
Atomic settlement is not free, and anyone selling it as a no-tradeoff upgrade is overselling:
- Capital lockup. Funds are immobilized for the timeout window. Choose timeouts too long and capital efficiency suffers; too short and you risk failed swaps under congestion.
- Liveness. Both sides must act within the window. For agents this is usually fine (they're always-on by design), but it's a real assumption, not a free lunch.
- Timeout and griefing surface. A counterparty can lock a swap and walk, costing you the lockup window even though you get refunded. Mitigations exist (collateral, reputation), but they add design weight.
- Operational complexity. Secret management, cross-chain timeout coordination, and refund paths are more moving parts than "send to escrow."
The honest framing is a risk swap, not a strict dominance: atomic settlement removes custody risk and counterparty-release risk, and in exchange takes on lockup cost and a liveness assumption.
Why the "who are you?" gap is the deciding factor
Notice that escrow's blind spot - counterparty identity - is also atomic settlement's blind spot if you stop at the HTLC. Atomicity guarantees the mechanics are honest (the swap can't be half-completed), but it doesn't tell an agent whether the address on the other side is who it claims to be.
That's why the interesting design isn't "HTLC vs escrow" in isolation. It's atomic settlement composed with a verified counterparty layer: the math removes the custodian and the trade only proceeds against a counterparty whose identity/reputation is attestable. Now both questions are answered - "is my money safe?" by the atomicity, and "who am I trading with?" by the directory - without anyone holding the funds. Identity/reputation registries like ERC-8004 are complementary infrastructure here, not competitors.
So which one wins?
I'm not going to pretend this is settled. Escrow has momentum, distribution, and the easier integration story. Atomic settlement has the cleaner trust model and no honeypot, but it asks builders to absorb lockup and liveness costs.
My structural bet is that escrow is the placeholder and atomic settlement is the destination - because the value flowing through agent-to-agent trade makes every custodial honeypot a growing liability, and the marginal cost of trust-minimization keeps falling as tooling matures. But that's a bet, and the strongest counterargument - "convenience always wins at scale, and a good-enough custodian beats a perfect protocol nobody integrates" - deserves a real answer, not a dismissal.
Where we stand on the building side: Hashlock's atomic settlement is live end-to-end on Ethereum mainnet, exposed to agents through an MCP server with six tools (create_rfq, respond_rfq, create_htlc, withdraw_htlc, refund_htlc, get_htlc). The MCP server is on npm as @hashlock-tech/mcp. We've written up the longer argument and the academic grounding below.
- Site: https://hashlock.markets/?utm_source=devto&utm_medium=article&utm_campaign=2026-06-25-escrow-or-atomic
- GitHub: https://github.com/Hashlock-Tech/hashlock-mcp
- Whitepaper (SSRN): https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6712722
One honest question to close on: for autonomous agents specifically, does the always-on, no-human-in-the-loop nature of agents make the liveness cost of atomic settlement basically free - and if so, does that tip the whole tradeoff? What's the strongest case for escrow staying the default? I'd genuinely like to be argued out of my bet.
