AI Crypto Roundup: Agent Commerce, Smartphone Compute, and Verifiable AI
The through-line in this AI-and-crypto discussion is that agent commerce is moving from demos toward settlement, identity, and verification, while decentralized compute and data networks try to supply the underlying capacity and provenance. The strongest claims are concrete and measurable; the weakest are generic infrastructure hype.
Agent commerce is converging on escrow, identity, and verifiable delivery
The substantive agent-commerce proposals now focus less on letting agents chat and more on how agents prove identity, lock funds, deliver work, and resolve disputes.
Escrow and dispute rules are becoming the core marketplace primitive
TermiX's Agent Autonomous Commerce Protocol is described as using ERC-8004 portable identity, reputation that updates only from settled outcomes, escrow that locks payment when a quote is accepted and releases against a deliverable hash written on-chain, provider stake that can be slashed, and dispute resolution by a random evaluator panel whose losing challenger burns a bond @mannan25195@mannan25195. The same agent can act as client on one job and provider on another, which removes a hard buyer/seller split @mannan25195@mannan25195. A separate summary describes the basic flow as buyer deposits budget into escrow, provider accepts, agent submits result, buyer reviews and accepts, then the contract releases payment under agreed rules, with cancellation, refund, objection, and dispute paths @aziashcrypto.
Verification is being split by task type
The AACP whitepaper is described as exploring four verification levels: manual evaluation, trusted execution environments, zero-knowledge virtual machines, and a combination of TEE and zkVM @EleNaincy65175. The author notes that deterministic tasks can be proved more cleanly than subjective outputs such as research reports or designs, so the protocol also explores rubric-based evaluation for subjective work @EleNaincy65175. The useful design point is that verification should match the nature of the job rather than pretending every AI output has a simple yes-or-no proof @EleNaincy65175.
Payment activity is measurable but incomplete
One meetup recap reported as of Oct 21: 192.2 million x402 settlements, 41.9 million dollars settled, 934,000 ERC-8004 agents registered, 12.36 million Virtuals ACP commerce memos, and 19.6 million Olas agent transactions @FinchTechAI. The same recap cautions that off-chain agent work such as private APIs and platform-internal task markets leaves no on-chain trace, so these figures are a public sample, not a census @FinchTechAI. Another post says AI agents have made over 138 million payments through x402 on Base, mostly micropayments for data, compute, and access @__Vik_tor. The author asks whether the durable opportunity is in agent-payment infrastructure rather than in tokens representing the AI narrative @__Vik_tor.
Fee transparency is becoming a design test
Motes is described as planning a 1% service fee on eligible agent activity, with revenue supporting protocol operations and planned token buybacks @Amenouboy. A more detailed analysis argues that gross fee receipts are not the same as net treasury revenue: operating and execution expenses must be accounted for, and reporting should separate fees accrued and received, reversals and refunds, operating expenses, treasury balances, and buybacks actually executed on-chain @ngochoa2k2. The author's standard is that an AI-agent economy should be judged by measurable financial flows rather than stated intentions @ngochoa2k2.
Mandates make autonomy bounded
Motes is also described as giving one NFT one agent identity and one dedicated smart account, where the owner defines allowed assets, trade size, daily cap, slippage, and stop conditions, and the account checks every action against those rules before execution @aiaeth7. The author frames this as autonomy with enforceable limits rather than autonomy for its own sake @aiaeth7.
Privacy is being framed as a payment requirement
One privacy-focused post argues that an AI agent economy will not operate on a public ledger because an agent that pays for APIs, data, and compute on a transparent chain publishes which tools it uses, how often, and how much @zano_project. The author's conclusion is that machines will need private money before anything else @zano_project.
Payment UX and liability remain unsolved
An analysis of the OpenAI Wallet argues that it creates no new payment rails: a card is added once, the agent mints a one-time network token, and the agent types it into normal checkout; the wallet holds zero dollars and OpenAI never becomes merchant of record @shafu0x. The same analysis says merchants block agents because bot rules were written for scrapers, and that sub-one-dollar micropayments remain too expensive @shafu0x. A payments operator argues that agentic payments will run on a 16-digit number for years until stablecoin wallets offer comparable chargebacks, dispute resolution, and clear liability @prajitn. Another critic argues that agentic commerce is over-focused on payments and under-focused on the UI and UX of agentic surfaces @juokaz.
Decentralized compute is testing smartphone-scale AI
Acurast is the center of this discussion: it turns smartphones into compute nodes, uses hardware-backed security, and demonstrates narrow AI inference on phones, but the open question is whether developers will pay for reliable recurring workloads.
Phone nodes are running narrow inference, not replacing GPU clouds
Acurast's Laya Tetris demo is repeatedly cited as a concrete workload: the game generates five possible placements, an AI model running on an Android phone evaluates them, and the selected move updates the board @HeyMila2008@0xamierr@duongphat99@mayflowers2x8. The demo is described as using the phone CPU rather than a centralized GPU server, with decision times around 0.2 to 1 second depending on the device @mayflowers2x8@_Juliaweb3. One author notes the model runs in under a second and that the interface shows the serving phone's country, specs, and on-chain record @_Juliaweb3. The same author cautions that a Tetris demo should not be extrapolated to every AI workload, but it does show which small, structured decisions phone hardware can handle @duongphat99.
Acurast claims larger models and developer-facing workloads
On Nov 6, Acurast demonstrated Qwen3.5-9B running directly on Android smartphones through its network, according to one post: a 9B-parameter model on a 16GB Android phone, no GPU, Docker, or traditional cloud account, an OpenAI-compatible API, more than 100 phones tested for distributed workloads, and around 5 to 10 cents per phone per day at measured market rates @BitWolf84. Acurast documentation is also described as supporting REST APIs, webhooks, scheduled tasks, automation, and LLM inference, with CLI and SDK access and a Deploy Agent workflow that supports USDC payments on Base through x402 @kodd25. The network is described as using hardware-backed security and remote attestation to verify devices and support confidential execution @kangbaby_, and as running agent tasks inside trusted execution environments so private data and transaction signing are protected @0xZane_.
Demand and reliability are the open questions
Supporters and skeptics converge on the same test: whether developers pay for recurring workloads rather than just joining a network @kodd25@kangbaby_. One author argues smartphone compute will not replace high-end GPUs for every workload because latency, memory, and device availability still matter, and the real opportunity is finding workloads where distributed, verifiable, and affordable compute beats centralized infrastructure @BitWolf84. Another says a network is only as strong as the people who actually depend on it and flags developer demand as the key metric @Axismeta.
Verifiable AI and data provenance are moving into protocol design
Verification is becoming a first-class design problem for AI agents: projects are building proofs for web-data origin, model execution, and on-chain reputation without exposing private inputs or model weights.
zkTLS attestations make web data portable to on-chain applications
Primus is described as offering a zkTLS JavaScript/TypeScript SDK that brings verifiable web data into applications using zero-knowledge proofs, with privacy-preserving verification, easier JS/TS integration, 100 free proof generations per appID, and a starting point for trustless data-driven applications @MDSumon68209331. A zkTLS attestation is described as recording data provenance such as request URLs, methods, headers, or response paths; verification conditions in an attConditions field; attestor address and task ID; recipient wallet; and timestamp @MDSumon68209331. One author argues this matters for DeFi, financial credentials, AI agents, and on-chain compliance because applications can reason about verified information without unnecessary private-data exposure @MDSumon68209331. Another adds the caveat that verifying where data comes from does not automatically make it accurate or unbiased, but source verification is a first step toward trustworthy AI systems @ox_aryan1.
Proof of inference targets model accountability without exposing weights
Proof of Inference is described as letting a party verify that a specific model produced a specific decision without access to the model's weights @MeshNeuro. In one example, an OEM protects its network while a regulator or insurer still confirms which model version ran and on what inputs, so the record settles what a robot decided and why while the intellectual property stays closed @MeshNeuro.
AI-driven reputation can be verified without full disclosure
Zeru's zscore is described as reading on-chain behavior and combining AI-driven analysis with zero-knowledge proofs so reputation can be verified without exposing everything @Axismeta. The author argues that if this works, good behavior compounds instead of resetting every time a user opens a new position, and that reputation is one of the most valuable and least developed primitives in DeFi @Axismeta.
Physical-world data networks are being wired to agents
Vangrid is building a bridge between autonomous software and physical-world data: agents can fund requests for real-world captures, while human contributors still perform the physical work and on-chain attestations record provenance.
Agents can commission physical captures through paid bounties
Vangrid is described as turning smartphones into a distributed 3D capture network: businesses request location-based data, local contributors capture it, faces and license plates are blurred on-device, and cryptographic fingerprints are anchored on Base for provenance verification @marcismus. The project is also described as using bounties to connect real-world data requests with contributors, letting AI agents request missing information through a bounty API, and supporting onchain attestations for data provenance @0x_zoda. In one described flow, an AI agent submits a paid API request using USDC on Base or Arc without an account, the full amount is paid upfront into the same escrow used by regular bounties, and the request appears on the bounty board with an AGENT label @nguyenvann6_24. Human contributors still perform the physical capture and go through the same preview and acceptance process @nguyenvann6_24.
Authorization and settlement are separate steps for agent-paid data
For Vangrid's paid data queries, an AI agent signs an EIP-3009 authorization before the request is validated; if the API rejects a malformed request with a 4xx error, x402 cancels settlement @77bncvbsdcg. That separation matters for autonomous software making frequent paid requests because authorization and actual payment are different steps, so failed requests do not become completed charges @77bncvbsdcg.
Provenance is not the same as identifying the right physical asset
One author points to an accepted 500-dollar city-centre bus shelter capture in Glasgow on Nov 13 and notes that a capture hash and location are useful evidence, but an asset-management system still needs to associate that observation with the correct physical structure among many similar ones @kengdaica. The author argues physical AI needs confidence about exactly what was observed, not just proof that something was observed @kengdaica. Another author warns that making agent-originated requests possible does not prove agents already generate recurring demand or that an autonomous data economy exists at scale @nguyenvann6_24.
Decentralized AI networks and user-owned data marketplaces
Bittensor, NEAR, and 0G represent three different bets on decentralized AI: an alternative network for AI production, a user-owned data marketplace for agent traces, and private verifiable inference infrastructure.
Bittensor is framed as an alternative to centralized AI
The Bittensor Foundation argues that decentralized AI is a necessary counterweight to regulatory capture that shields AI oligopolies from competition, and that Bittensor gives people a way to build that alternative and own a stake in it @opentensor. A creator with almost two years in the ecosystem argues that Bittensor is well suited to AI agents and explains who pays contributors, what real products and customers exist, and where revenue comes from @VictorVL_EN. Those are ecosystem claims and opinions, not independently verified results.
User-owned data marketplaces aim to sell agent traces
NEAR's AI Gateway is described as a desktop app for people building with Claude Code, Codex, and OpenCode: after downloading, users can switch to private models, see where tokens and money are going, and earn inference credits for accepted session traces they choose to contribute @Cameron_Dennis_. Traces are redacted on the Mac and each one is approved before sharing @Cameron_Dennis_. The team says five months of conversations with AI researchers and RL teams found commercial value in how agents tackle problems, fail, and eventually succeed, and argues users should control those traces and be able to sell them directly to labs @Cameron_Dennis_. The same post positions private inference as the foundation for a user-owned AI data marketplace @Cameron_Dennis_.
0G builds private inference and verifiable execution, but adoption is still early
0G is described as building infrastructure for decentralized AI: Encrypted Transit in 0G Private Computer protects AI prompts through routing using trusted execution environments; Infinite AI connects staking with daily compute credits across more than 100 AI models; GLM-5.3 runs fully sealed inside TeeML on 0G; and the Builder Hub supports decentralized compute, storage, AI agents, and verifiable execution @sallubroz. The same post reports 400+ integrations and 350+ projects in an H1 2026 update, but also notes a gap between technology and economic adoption: Token Terminal showed 768 monthly active addresses, a reported 7,502.6% increase, about 0.1% active-address share across 38 chains, roughly 2.88 million dollars in tracked DeFi TVL, and relatively small stablecoin liquidity @sallubroz. The author's conclusion is that the real test is whether developers and businesses pay for decentralized compute, private inference, and verifiable AI execution @sallubroz.
Agent finance and on-chain execution
On-chain agent finance is moving toward standard primitives for identity, payments, and execution, but the practical limits are still set by operator permissions and risk controls.
On-chain agents are getting identity, payment, and execution primitives
Injective is described as combining MCP, an AI Agent SDK, ERC-8004, and x402 so agents can operate independently on-chain, build verifiable identities, interact with applications, move funds, and generate revenue @Jife790. Another post describes agents checking market prices, buying data with USDC through x402, making on-chain trades, and earning fees when trades complete, all within operator-set limits @zynehqx.
The common unresolved issues are demand, liability, and verification fit
Across agent commerce, smartphone compute, and physical-data networks, the same open issues recur: whether real demand exists beyond incentives @kodd25@nguyenvann6_24, whether verification matches the subjectivity of the task @EleNaincy65175, whether liability and dispute rules are enforceable @mannan25195@prajitn, and whether provenance is enough to identify the right real-world asset or data source @kengdaica@ox_aryan1. The projects with the most concrete mechanics are also the ones that openly state these limits, which is a better signal than generic claims that agents will soon run the economy.