The NovaNet team led Circle's inaugural livestream for Arc to showcase how zero-knowledge machine learning (zkML) proofs can power the next generation of agentic commerce. The discussion is about where autonomous AI is headed—and what it takes to make it trustworthy.
We're entering an era where AI agents don't just answer questions—they spend money.
They'll book your flights, pay your invoices, negotiate with vendors, and execute transactions on your behalf while you sleep. This is agentic commerce: autonomous systems acting as economic participants, wielding wallets and making financial decisions at machine speed.
But here's the question no one has adequately answered: When an AI agent moves money, how do you know it did what it was supposed to do?
That's what we built on Arc to address—a collection of demos showing how zkML can bring cryptographic trust to the agentic commerce stack.
Think about what's coming. AI agents that can:
This isn't science fiction. The building blocks exist today.
Circle's OOAK framework gives agents wallet capabilities. The x402 protocol enables HTTP-native micropayments. Stablecoins like USDC provide programmable money that moves instantly.
But here's the uncomfortable reality of today's AI agents: they're black boxes with bank accounts.
An agent makes a payment decision and logs it. Maybe it generates a report explaining its reasoning. Looks auditable. Feels professional. But what does that log actually prove? Absolutely nothing that couldn't be fabricated by a compromised system, a malicious actor, or a bug.
When agents are just answering questions, this trust gap is manageable. When they're moving money—your money, your company's money, your customers' money—it becomes a fundamental problem.
Consider these situations:
In agentic commerce, the stakes are too high for "trust me."
Zero-knowledge machine learning solves this by generating mathematical proof that a specific computation occurred exactly as claimed. With zkML, every agent decision comes with a cryptographic receipt proving:
The Arc repository includes demos that show how zkML-verified agents work with Circle's products.
This demo extends Circle's OOAK framework and integrates with x402 for HTTP 402 micropayments. The agent owns its wallet via private key—true ownership, no custodian—and can make autonomous payment decisions.
The difference from traditional agents? Every spending decision generates a zkML proof. The proof attests that the authorization model ran correctly on the specific request parameters. The proof hash gets committed on-chain, creating an immutable record.
The implication for agentic commerce: you can deploy spending agents from third-party providers, or even untrusted sources, and still verify their behavior. The cryptographic proof substitutes for institutional trust.
Compliance is the gatekeeper of agentic commerce. Before an agent can move money at scale, someone needs to ensure it's not paying sanctioned entities, terrorist financiers, or other prohibited counterparties.
This demo integrates with Circle's Compliance Engine API, performing dual-sided screening of sender and recipient addresses against:
Every compliance decision generates a zkML proof that the screening actually happened and the results actually fed into the authorization logic. This isn't a log entry claiming compliance was checked—it's cryptographic proof that it was.
For regulated entities exploring agentic commerce, this creates the audit trail that makes autonomous transactions possible.
Zero-knowledge proofs have a reputation for being slow. Traditional ZK systems can take minutes or hours to generate proofs. That's fine for some applications, but it's a non-starter for commerce that needs to move at the speed of business.
The Arc demos are built on JOLT-Atlas, NovaNet's zkML prover.
Its sub-second proof verification means smart contracts or backend services can validate proofs without meaningful latency.
This is zkML that's practical for production commerce.
Every transaction through Arc follows a consistent flow:
That on-chain commitment creates a timestamped, tamper-proof record. Months later, auditors can verify that a specific proof existed at a specific time, anchoring the entire decision chain to an immutable ledger.
This is what the trust layer for agentic commerce looks like: agents that can prove their behavior, not just report it.
If you're building toward agentic commerce—autonomous systems that handle money, procurement, or financial operations—here's why this matters:
zkml-client handles proof generation; arc-utils manages blockchain interactions.
Agentic commerce will reshape how business gets done. But this future only works if we solve the trust problem, and zkML provides the trust infrastructure that makes agentic commerce viable.
