Problem
AI agents are moving real money on-chain, autonomously, faster than anyone can check what they're acting on. They receive a number from a data feed and sign a transaction on it, without knowing if that number is fresh, correct, or manipulated. When the data is wrong, the agent doesn't fail at the payment. It fails at the decision underneath it, and that's how money gets lost. It already has a body count: an AI trading agent was exploited for $216,000 this year, and generating a working exploit now costs as little as $1.22. The failure isn't the agent's code. It's the data it trusts. Metera solves this by verifying on-chain data before an agent acts, scoring how much to trust it, and refusing when it can't verify, so an agent never acts blind.
Solution
Metera sits between an agent and the transaction it's about to make. Before the agent acts, it asks Metera to verify the on-chain state it's relying on, a price, a token's risk, a wallet balance, a pool's reserves. Metera reads that state from independent sources at the same slot, and returns three things: the value, a confidence level (single-source, consensus, or anchored), and the source. When the data doesn't hold, or the sources disagree, Metera refuses instead of guessing, and refusals are free. Every check is anchored on Solana, so anyone can recompute the hash and verify the record without trusting us. The agent reads the trust level programmatically and decides whether to act. We recently proved the full loop: an agent's transfer to an OFAC-sanctioned address was blocked by Metera before it ever reached execution. Verification decides, then execution happens, never the other way around.
Business model
Usage-based: agents pay per verified call, and refusals are free. They only pay for answers that pass verification, which aligns our incentives with delivering something trustworthy. Billing runs through credits (Stripe), with plan tiers (Free, Pro, Scale) adding a subscription layer for higher-volume customers on top of usage.
Average ticket is built bottom-up at ~$3,000/customer/year at target scale, and it scales with each agent's activity. A low-frequency research agent pays little, while a high-frequency trading or DeFi agent making thousands of checks pays far more. Revenue grows with usage, not capped at a flat seat price.
We're early, with around 40 users testing and no meaningful revenue yet, so the ticket is a projection, not a realized number. As agents move more value on-chain and verify more before acting, ticket size grows with them.
Market
TAM ~$50B: the global AI agent market by 2030 (Grand View Research, ~45% CAGR). For context, agents are projected to influence $15T+ in on-chain and commercial transactions by 2030 (Gartner) - that's the value flowing through agents, and none of it is safe to act on unverified.
SAM ~$3.75B: data verification for financial agents, our slice of the on-chain oracle/verification market ($12.5B by 2034, Intel Market Research, ~30% financial).
SOM ~$50M: financial agents Metera can realistically reach in 3 years.
Competitors
Direct: data providers that agents use for on-chain data. Pyth and Switchboard sell price feeds; Birdeye and Helius sell raw token and market data. They all hand the agent a number and walk away, none return a confidence level, none refuse when they can't verify, and none anchor proof on-chain. They're the feed; we're the gate.
Adjacent: the larger players (Chainlink, RPC providers) could move into agent verification, but they're built for humans and dApps reading data, not autonomous agents deciding whether to act at the moment of signing.
Why we win: refusing to ship a number you can't stand behind is a discipline you build a company around, not a feature you bolt on. A coverage-first provider can't retrofit "we say no when we're unsure" without fighting their own incentives. The moat isn't the tech, it's the posture, and the on-chain track record of correct refusals that compounds over time.
Competitive differentiation
Our edge isn't better data, it's refusal as a discipline. Competitors optimize for answering; we optimize for knowing when not to. A coverage-first provider can't bolt on "we say no when unsure" without fighting their own incentives. On top of that, every refusal is anchored on-chain, building a verifiable, compounding track record of when we were right to hold back, a reputation earned call by call, not cloned. And we're built for the agent's decision (structured output, programmatic trust levels, refusals an agent can branch on), not for a human reading a dashboard. The tech is copyable; the posture and the proof trail are not.
Entry barrier
The idea is copyable in a week; the barriers aren't. First, a compounding on-chain proof trail: every refusal is anchored publicly, so we accumulate a verifiable record of when we were right to hold back, call by call. A new entrant starts at zero and can't fork a reputation. Second, a validated independence map, knowing which sources are genuinely independent versus reading the same upstream is hard-won, and getting it wrong means faking corroboration. Third, switching cost: once an agent's execution depends on our gate, replacing us means re-architecting how it decides. Time, trust, and integration depth are the moat, not the code.
Traction
Early but real. Metera is live on Solana mainnet with around 40 users testing via MCP and API. Every verification and refusal is anchored on-chain, so the usage is publicly verifiable, not a claim.
We already have a live use case with Webacy (DD.xyz): they're our token-risk data source, we route real agent queries to them, and they're featuring Metera in their marketing. We're also listed in Superteam Perks. We started as gate402, placed 9th in a Colosseum sidetrack, then pivoted to Metera.
Most recent milestone: we built a working integration where Metera acts as a verification gate before on-chain execution, blocking an agent's transfer to an OFAC-sanctioned address before it reached the execution layer.
Honest state: no meaningful revenue yet. The traction is product in production, real usage, a live data partner, and proof the core thesis works end-to-end.