M–ONE

The judgment layer for agent data.

M–ONE decides which source your agent should trust, verifies the answer before it ships, and labels exactly how confident it is. It never claims data is true. It tells you how much it knows — and it has never once overstated that.

Sign up for freeTalk to the team

The problem

Your agent needs data. It calls an API. Something comes back.

Nothing in that chain checks whether the answer is correct. If you read a bad response, you notice. If your agent reads it at 3am, it becomes a decision.

Directories in this space rank sources by transaction volume, buyer reach, and recency. Those are popularity metrics. None of them measure whether the answer was right.

What M–ONE does

Selects

Every request is routed to the source most likely to deliver, based on measured reliability — not on listings, not on popularity, not on who paid to be listed.

Verifies

The response is checked before it reaches you. Structure, freshness, plausibility, agreement with independent sources, and — where a chain or oracle provides ground truth — agreement with that.

Fails over

A source that fails verification is swapped mid-request. Your agent sees a slightly higher latency. Nothing else.

Labels

Every response ships with the verification level it earned, and a trace of how the decision was made.

Verification levels

This is the part that matters.

  • anchored — the answer was checked against an independent authoritative reference, typically on-chain state or a signed oracle, and agreed with it.
  • consensus — the answer agreed with independent sources. Independence is measured, not assumed: sources that turn out to read the same upstream count as one source, not several.
  • single_source — the answer passed structural and plausibility checks, but no independent confirmation was available. It may be right. We could not confirm it, and we say so.

A high level is not a guarantee of accuracy. It is a statement about which checks were performed and passed. You set the minimum level your agent will accept. Below it, we refuse the delivery rather than dress up an unverified answer.

That refusal is the product working, not failing.

What it caught

M–ONE was built against adversaries before it was pointed at the real world.

  • A source that lies convincingly — passes every structural check, returns a plausible wrong number. Wrong deliveries went from 78.5% to 0.5%.
  • Two sources that lie together — a colluding pair in a category with no ground truth is informationally indistinguishable from the truth. No statistical judge resolves this. M–ONE does not pretend otherwise: it labels those answers as unconfirmed, every time.
  • Sources that look independent and aren't — five providers, five different names, one shared upstream. Before detection, they produced 575 confidently wrong "consensus" deliveries. After, zero. Not because the data got better — because the label got honest.
  • A source farm — a hundred fake listings arriving at once to drain the exploration budget. Wasted spend: fractions of a cent.

Across every adversarial scenario, mislabeled rate: 0%. Data can still be wrong. The label describing our confidence in it never is.

Measured against the real world

Simulation tells you the engine works. It doesn’t tell you what the world is like.

500 live calls against independent exchange feeds, judged against a signed on-chain oracle. Zero lies, zero unavailable. Lying rate below 1% at 95% confidence — reported as an interval, because a rate reported as a single number is not a measurement.

Independence, verified rather than assumed. Two exchange feeds tested at residual correlation r=0.154 — genuinely independent. Two social data providers tested at 100% exact agreement across eleven handles: identical to the byte. They were not two observations. They were one, counted twice. M–ONE refused to call it consensus.

What it isn't

Not a catalog

Anyone can index endpoints. M–ONE decides which one deserves the call.

Not an oracle

We do not produce data. Everything delivered comes from third parties. What we add is selection, verification, and an honest label.

Not a guarantee

No level guarantees correctness. anchored means it agreed with a reference at a point in time — the reference can be wrong too. Where the stakes are high, verify independently.

Not a black box

Every response carries the reasoning: which source, why that one, what the alternatives scored, what was checked, what it cost.

How to use it

Over MCP — one command, and Claude Code, Cursor, or Codex can query verified data directly.

claude mcp add --transport http metera https://api.metera.xyz/mcp \
  --header "Authorization: Bearer $METERA_KEY"

Over HTTP — one endpoint, one key.

curl https://api.metera.xyz/v1/ask \
  -H "Authorization: Bearer $METERA_KEY" \
  -d '{"query":"SOL price"}'
{
  "data": { "token": "SOL", "priceUsd": 72.46 },
  "verification": {
    "level": "anchored",
    "source": "okx",
    "cost": "0.0015",
    "traceId": "tr_dr29wv"
  }
}

In the SDK — three lines.

import { Metera } from '@metera/sdk'
const metera = new Metera(process.env.METERA_KEY)
const { data, verification } = await metera.ask('SOL price')

Test keys return fixtures with the same shape and no charge. Integrate before you pay.

Under the hood

Routing is arithmetic over measured reliability, not a model call. The decision runs in under a millisecond at p99 — a language model in that path would cost more than the data it selects.

Exploration is demand-driven: the more uncertain the catalog, the more the engine spends learning, within a hard ceiling. Reliability estimates decay when a source goes unobserved, so a source that recovers gets tried again without anyone intervening.

Verification runs in layers, cheapest first. Most responses never reach the expensive one.

Start

Free tier, no card. Ask a question and see the level it comes back with.

Start asking