The open translation layer from onchain events to audit-grade ISO records.
Joined March 2022
- Tweets 275
- Following 77
- Followers 877
- Likes 9,855
16 Photos and videos
Pinned Tweet
Jun 3
Today we’re launching the x402 facilitator on Coston2 under ProofRails:
x402test.proofrails.com/
x402 alone is a payment gate.
ProofRails turns that payment into a verifiable financial workflow that agents, enterprises, and institutions can build on.
This first demo uses mocked USDT0 in an agentic flow to unlock a gated report page.
After the normal x402 payment flow, ProofRails creates an evidence record, anchors the bundle hash on Flare, and makes the flow independently verifiable afterward.
3
8
43
12,913
ProofRails retweeted
One thing I've learned while building on @FlareStudioXYZ @ProofRails SDK is that great tooling isn't enough.
Another day Demoing the SDK.
The goal isn't just to show what the SDK can do, but to make the flow easy to understand and experiment with.
Building continues.
1
4
15
308
ProofRails retweeted
Jun 11
Interesting step from “payment request” → “verifiable agent workflow”.
x402 handles the paywall, but @ProofRails is what turns it into an auditable trail agents and institutions can actually rely on.
This is where agentic payments start becoming real infrastructure.
Jun 3
As agents start paying for APIs, data, reports, and services, the payment flow can do more than a transaction hash.
This demo shows how Flare can support paid agent/API access where the resource unlocks and ProofRails creates a receipt and verification path afterward.
Another building block for developers experimenting with agentic payments. ☀️
1
1
11
331
ProofRails retweeted
Jun 9
If you like this vision, you are going to enjoy some of the upcoming deployments we are preparing for @ProofRails
The agent is the first customer specifically trained to not be patient.
A person waits out the weekend and high fees because we learned to think it's normal. Software paying for every API call just routes around a system full of inefficiencies.
A world run by agents is one where money finally moves the way it always should have: everywhere in seconds.
2
5
39
890
ProofRails retweeted
Jun 3
Payment is step one. Proof is what makes it usable.
Good to see @ProofRails testing that on Coston2.
We suggest others to give it a try: x402test.proofrails.com
7
44
785
ProofRails retweeted
Jun 7
Most crypto payments end with a transaction hash.
@ProofRails is exploring what comes next:
payment → evidence → verification -> audit trail.
As agents handle more economic activity, proving what happened may become as important as settlement itself.
1
2
14
151
ProofRails retweeted
Spent yesterday building @ProofRails TypeScript SDK.
✅ 10 typed clients
✅ CLI support
✅ Strong TypeScript types
✅ Custom fetch injection
✅ Smoke tests against the live backend
✅ Route-focused testing
Just got the test suite green:
6 tests passed.
0 failed.
#BuildInPublic
3
1
15
318
ProofRails retweeted
This is the point. Because the missing layer is not just another payment rail or stuff like that, it is the proof.
That’s why ProofRails being selected for EBA day FinTech Zone matters is a real door into european banks, not just another crypto crowd.
People can say #Flare is slow. Maybe.
But for this kind of race, I’d rather have a marathon runner than a sprinter
People have to understand that building rails that banks can actually use takes time. Institutions don’t want “maybe”.
They need scale, security, verified data, confidential workflows and auditability etc..
@ProofRails is working on the proof/reconciliation part.
TEEs/FCC can bring the confidential compute part.
And this is where Flare’s data native stack starts to make more and more sense in my opinion.
Good job guys !
#DeFi #Finance
Jun 4
We are pleased to share that ProofRails has been selected as one of the finalists for the Euro Banking Association’s EBAday 2026 Fintech Zone in Copenhagen.
EBAday is one of Europe’s key payments and transaction banking events, bringing emerging fintech infrastructure in front of senior banking executives, judges, and payments industry leaders.
For ProofRails, this is key, as we are building infrastructure that converts blockchain payments into structured, verifiable financial records compatible with standards like ISO 20022.
Digital asset payments are entering real financial operations. The missing layer is not another payment rail, but the records, evidence, and reconciliation infrastructure that institutions can actually use.
See you in Copenhagen on 16–17 June.
5
18
547
Jun 4
We are pleased to share that ProofRails has been selected as one of the finalists for the Euro Banking Association’s EBAday 2026 Fintech Zone in Copenhagen.
EBAday is one of Europe’s key payments and transaction banking events, bringing emerging fintech infrastructure in front of senior banking executives, judges, and payments industry leaders.
For ProofRails, this is key, as we are building infrastructure that converts blockchain payments into structured, verifiable financial records compatible with standards like ISO 20022.
Digital asset payments are entering real financial operations. The missing layer is not another payment rail, but the records, evidence, and reconciliation infrastructure that institutions can actually use.
See you in Copenhagen on 16–17 June.
7
9
32
2,687
ProofRails retweeted
Jun 3
Agent payments should not stop at a transaction hash.
On Coston2, @ProofRails and @FlareDevHub show a payment-to-proof loop: x402 pay-to-unlock, Flare settlement, then a finance-readable receipt you can verify later.
This will be huge, and it's only just the beginning☀️
1
3
32
761
ProofRails retweeted
Jun 3
As agents start paying for APIs, data, reports, and services, the payment flow can do more than a transaction hash.
This demo shows how Flare can support paid agent/API access where the resource unlocks and ProofRails creates a receipt and verification path afterward.
Another building block for developers experimenting with agentic payments. ☀️
Jun 3
Today we’re launching the x402 facilitator on Coston2 under ProofRails:
x402test.proofrails.com/
x402 alone is a payment gate.
ProofRails turns that payment into a verifiable financial workflow that agents, enterprises, and institutions can build on.
This first demo uses mocked USDT0 in an agentic flow to unlock a gated report page.
After the normal x402 payment flow, ProofRails creates an evidence record, anchors the bundle hash on Flare, and makes the flow independently verifiable afterward.
10
22
106
8,100
ProofRails retweeted
May 29
Got access to Devin CLI through this opportunity!
I’m going to test it on a real @ProofRails build: an adapter that turns AI dev-agent work into verifiable evidence bundles.
First goal: capture prompts, commits, diffs, tests, API calls, payments, and anchor the final proof on Flare.
Will share the process.
May 28
Claude Opus 4.8 is now available in Devin CLI ⚡️
I'm giving away 10 @devinai Max subscriptions ($200 each) for you to try it out!
Just comment below with what you're building or want to build to enter!
1
7
41
1,355
ProofRails retweeted
May 28
I asked Claude Opus 4.8 a simple question:
what are the top 3 dApps or solutions @FlareNetworks needs most at this stage? 👀
May 28
I'll be busy for the next 15 hrs, see you tomorrow 🫡
9
9
74
3,637
May 27
It's been quiet around here, should we deploy today?
May 27
It's a beautiful day to deploy on @FlareNetworks ☀️
4
4
28
1,420
ProofRails retweeted
May 26
Most chains can run smart contracts.
A few support TEEs.
None combine everything Flare does in a single protocol stack that can be used by agents:
May 26
What will Flare Confidential Compute enable for AI agents?
Here are some use cases:
1. Verifiable inference: you can prove onchain that a specific model with a specific prompt produced a specific output. Today you can't verify that an AI agent actually ran the model it claims to have run. FCC makes that verifiable.
2. Private inputs with public proofs: an agent can consume sensitive data (private API keys, confidential business logic, etc) inside the enclave without that data ever being visible onchain or to the node operator. Only the output and the attestation are surfaced.
3. Secure key custody: agents can hold and use signing keys inside the enclave. The key never leaves the TEE, so the agent can sign Flare transactions trustlessly without a custodian.
4. Trustless agent-to-agent payments: combine FCC with x402/FTSO and you get agents that can negotiate and settle with each other based on verifiably correct computations, not just claimed outputs.
2
22
81
2,940
May 13
What stands out is that the missing layer is not only interoperability of assets, but interoperability of operations.
If value moves across multiple rails, then actions also need to become legible, governable, and provable across systems.
That is where ProofRails fits.
Machine-to-machine payments, agent execution, tokenized asset workflows, cross-rail settlement.
None of that scales cleanly if the output is just a transaction hash.
You need structured receipts, verifiable proofs, policy-aware execution, and audit-ready records that other systems can actually consume.
Moving tokens is one part of the stack. Making tokenized actions institution-readable is another.
This @CantonNetwork report describes a world where Ethereum stays a center of gravity for RWA, but clearly not the only one. The future will not be one winning chain.
Canton can serve institutional issuance.
- Ethereum can carry DeFi liquidity.
- XRPL can serve payment / settlement.
- And other rails will connect.
That is the Internet of Value: less silos, more circulation.
But the most interesting part is that the report is not only about “putting assets onchain”. It talks about an interoperability stack:
standardized payments, identity, compliance, data aggregation, analytics, intelligent orchestration, AI agents.
And #x402 is explicitly mentioned as an economic/service layer for machine to machine transactions.
This is where @ProofRails is not a gadget.
Imagine if tomorrow agents need to pay, generate receipts, verify proofs and anchor operations, this kind of machinet o machine payment becomes a real brick of the RWA architecture.
Same thing for AI agent orchestration.
These agents will monitor, adjust, move and optimize assets across several environments.
But they will need to be framed by risk management, programmable rules, verifiable proofs and auditability.
This is exactly where projects like Sentora, Firelight, ProofRails, and maybe an agent like @OfVoice25355 / $ADM if it evolves in that direction, become interesting.
The report basically says that efficient interoperability is not only about moving tokens.
You also need to verify data, prove rights, audit flows, manage risk, execute rules, protect sensitive data, and orchestrate assets across multiple rails.
Let’s not lie: this report describes a lot of problems Flare seems to be building for since a long time.
- FDC for data.
- FTSO for prices.
- FCC/ TEEs for confidential compute.
- ProofRails for receipts/proofs.
- @Firelightfi for risk.
- FSA/PMW for programmable execution.
The report does not mention @FlareNetworks. But the alignment between the @CantonNetwork /RWA narrative and what Flare is building is very interesting.
Any comment from the #Flare team or @HugoPhilion would be welcome. And if there is silence, I would also understand why... 👀
#Flare #RWA #Canton #ProofRails #DeFi #Tokenization #XRPL #NDAs
2
5
26
1,008
ProofRails retweeted
May 1
This implementation lets agents on @FlareNetworks request paid API operations through x402-compatible flows, generate or verify receipts, create ISO 20022-style payment records, and anchor proofs onchain.
Builders on Flare are getting more than DeFi primitives.
They are getting better rails for verifiable payments, agent workflows, and audit-ready records. 📃
May 1
ProofRails agentic branch is live! 🥳
This branch extends ProofRails v2 with x402 payments, AI/XMTP agent workflows, agent-triggered anchoring, FTSO price context, and SDK support for TypeScript and Python.
What can builders do with it?
Turn onchain transactions into ISO 20022-style payment records and:
Generate audit-grade evidence bundles.
Anchor receipt hashes on Flare.
Gate premium API endpoints with x402 payments.
Let agents pay for, generate, verify, and anchor payment evidence.
Use the Web UI, SDKs, or XMTP agent to interact with the system.
This is a pre-release branch, with the goal of making the agentic payment evidence layer public, testable, and easier for builders to extend.
Repo:
github.com/proofrails/middle…
1
10
54
2,042
ProofRails retweeted
May 1
This opens up a new layer for builders on Flare.
ProofRails moving into agentic workflows means developers can go beyond simple transactions — into automated payment logic, verifiable evidence, and programmable workflows.
For devs, this is about building systems that can generate, verify, and act on payment data autonomously, while staying anchored on @FlareNetworks.
Early, but a meaningful step toward more intelligent onchain applications ☀️
May 1
ProofRails agentic branch is live! 🥳
This branch extends ProofRails v2 with x402 payments, AI/XMTP agent workflows, agent-triggered anchoring, FTSO price context, and SDK support for TypeScript and Python.
What can builders do with it?
Turn onchain transactions into ISO 20022-style payment records and:
Generate audit-grade evidence bundles.
Anchor receipt hashes on Flare.
Gate premium API endpoints with x402 payments.
Let agents pay for, generate, verify, and anchor payment evidence.
Use the Web UI, SDKs, or XMTP agent to interact with the system.
This is a pre-release branch, with the goal of making the agentic payment evidence layer public, testable, and easier for builders to extend.
Repo:
github.com/proofrails/middle…
7
25
865
ProofRails retweeted
May 1
Very happy with this new agentic release!
With this version agents can not only pay, but also generate records, verify bundles, and anchor proof onchain.
For Flare, this is a natural fit: verifiable records, FTSO price context, and a bigger path with FDC-backed verification, FAssets payments, and possible Smart Account-triggered flows.
XRPFi will need more than liquidity.
It will need records, proofs, and rails that institutions and agents can actually use.
May 1
ProofRails agentic branch is live! 🥳
This branch extends ProofRails v2 with x402 payments, AI/XMTP agent workflows, agent-triggered anchoring, FTSO price context, and SDK support for TypeScript and Python.
What can builders do with it?
Turn onchain transactions into ISO 20022-style payment records and:
Generate audit-grade evidence bundles.
Anchor receipt hashes on Flare.
Gate premium API endpoints with x402 payments.
Let agents pay for, generate, verify, and anchor payment evidence.
Use the Web UI, SDKs, or XMTP agent to interact with the system.
This is a pre-release branch, with the goal of making the agentic payment evidence layer public, testable, and easier for builders to extend.
Repo:
github.com/proofrails/middle…
3
9
61
2,383