Agentic commerce is here. I won't spend time arguing why, since there's plenty written on that already. What I couldn't find was a clean way to pay for work: commit the money upfront, check whether the work actually happened, then release it or send it back. So I built the smallest version of that I could run. It's called Settle, it's live, and it's small: settle.ronakdaya.com.
curl -fsSL settle.ronakdaya.com/skill.md | claude
01 How I got here
After I left Paxos I spent a while tinkering, running flows across the primitives that make agentic payments work today: x402, Cloudflare Workers, stablecoins (the part I know best), MPP, AP2. I wanted to see where the rails are solid and where they aren't.
One thing kept nagging at me. Almost everything is built around instant payment: agent asks, agent pays, agent gets the thing. But work usually takes time, and it needs verifying before money should move. The instant model has nowhere to hold that gap.
Escrow is the obvious answer, and it mostly doesn't fit. On-chain escrow is good at on-chain proofs but blind to an HTTP check, a merged PR, or a person saying "done." Off-chain escrow handles the humans but settles slowly, shows you little, and isn't all that reliable. I wanted one contract object whose condition could be any of those, and that still lands in the same handful of end states either way.
So I built a small version to fix it: Claude to run the workflow, Claude Design for the brand and UX, Codex for the code. It's live. Here's what it does.
02 What it does
A contract has six fields: client, provider, amount, deadline, condition, fallback. The client commits funds upfront. The funds sit held while the work happens. Something checks the condition. The money then releases to the provider or returns to the client. Every transition fires a signed webhook, and you can rebuild the whole path from that stream, so nothing about how a contract reached a state is hidden.
Conditions in v0.1 are kept simple: api_response, github_pr_merged, file_delivered, manual. Here's a real contract that walked the whole path: funded, verified, paid out, settled, with real transactions on both ends.
03 What it is, and what it isn't
It's a custodial demo for tiny amounts. Both stablecoin rails run the full loop end to end (create, fund, verify, pay out on-chain, settle), and each has done it with real, small funds.
And here's what it isn't, so nothing reads as hidden:
04 Tell me where it's wrong
I'd like to hear from people building agent tools, paid APIs, bounty flows, or small freelance handoffs. Run a tiny contract and tell me where the shape breaks. The things I'm unsure about:
- Does the contract object (client, provider, amount, deadline, condition, fallback) cover your case, or is there a field missing?
- Which condition would actually pull you in: API response, GitHub PR, file delivery, or manual?
- Is
/skill.mdenough for your agent to integrate in one shot, or did it leave you guessing? - Where does the payout feel too manual, and where does it feel too magical to trust?
The agent-friendly way in is one line: curl -fsSL settle.ronakdaya.com/skill.md | claude. If you'd rather read first, the examples and recipes have copy-paste contracts for each condition type. If something breaks, and it will, reply wherever you found this or email me at hi@ronakdaya.com with the part that broke.
This is v0.1 and things will be wrong, which is why it's out now rather than later. A write-up of how it was built, including the Claude and Codex workflow and the reusable skills behind it, is coming next.
Ronak