EVIDIQ Atlas: A Pay-Per-Call AI Dataset Analysis MCP for Agents That Refuse to Read 2GB CSVs

You hand your agent a 2GB CSV of last quarter's transactions and ask "what's going on?" What does it actually do? If the honest answer is "dump the first 200 rows into context and squint," you've already felt the gap EVIDIQ Atlas was built to close.

What Is a Dataset-Analysis MCP?

An AI dataset analysis MCP is a Model Context Protocol server that lets an agent profile, query, visualize, compare, and research datasets via tool calls instead of loading entire files into context. EVIDIQ Atlas is a pay-per-call AI dataset analysis MCP where deeper tools cost more and every report is anchored on 0G Storage with a signed, re-verifiable result.

Most agents don't need the whole dataset — they need answers. Schema. Distributions. Anomalies. A clean comparison against last quarter. A quick plot they can hand to a human. None of that requires shipping 2,000,000 rows into the model's context window. It requires a server that knows how to read the file once and return structured findings the agent can reason over.

That's exactly what Atlas does. It exposes a small set of focused MCP tools — each one a discrete piece of analysis, each one priced by depth, each one returning a deterministic report you can verify after the fact. We built it for the same reason we built the rest of EVIDIQ: agents shouldn't have to trust unverifiable side effects. They should have receipts.

If you've poked at the EVIDIQ docs, you've seen that Atlas sits alongside the trust-scoring surfaces — same x402 payment rail, same 0G Storage anchoring, same signed evidence trail. The difference is the job: Atlas answers questions about data, not about agents.

Five Tools, Priced by Depth

Atlas exposes five paid tools and a handful of free helpers — the working surface of our AI dataset analysis MCP. Deeper analysis costs more because it does more, and because cheap prompts shouldn't subsidize heavy compute.

Here's what you actually call:

• profile_dataset — the cheap starter call. Returns schema, row count, column types, null ratios, basic stats, and a few sample rows. The "what is this file" question.
• query_dataset — runs a SQL-like query against the data and returns rows plus a summary. The "give me the answer" question.
• visualize_dataset — produces a chart spec (PNG and metadata) for a column pair or aggregate. The "show me" question.
• compare_datasets — diffs two datasets on schema, distribution, and key metrics. The "did this change?" question.
• research_dataset — the heavy hitter. Multi-step analysis: hypothesis, exploration, cross-tab, narrative findings, and a linked artifact bundle. The "tell me what matters" question.

Pricing scales with depth, not with bytes. A profile is a few cents. A research_dataset call — which can run a planner, multiple query passes, and a chart — costs an order of magnitude more, because that's what it costs us to compute honestly.

The free helpers are the boring plumbing that makes the paid tools usable. Concretely:

1. atlas_capabilities — returns the tool list, current prices, and supported dataset sources (CSV, Parquet, JSONL, hosted URLs).
2. validate_dataset_source — confirms a URL or handle is reachable before you spend a paid call on it.
3. estimate_cost — given a source and intended tools, returns an upper bound in USDT0 so an agent can budget.
4. verify_atlas_report — re-fetches a report, re-hashes the canonical evidence, and confirms the EVIDIQ signature on it.
5. get_artifact — pulls a previously-generated chart or result bundle by ID.

Honest take: most agents only need profile + query + visualize 90% of the time. research_dataset is the one you reach for when the human asks an open-ended "what's going on?" and you genuinely don't know which question to ask first.

Why an Agent Should Not Swallow a 2GB CSV

Three reasons, all of them painful.

Speed. Tokenizing 2GB of CSV into a context window takes minutes, then inference takes minutes, then the model often runs out of context and silently truncates the file. A profile_dataset call returns in under a second and gives the agent the schema, the null counts, and the cardinality of every column. Now the agent knows what it's looking at before it spends a single token on a prompt.

Cost. 2GB of CSV at roughly 4 bytes per token is about 500M tokens. At any frontier-model price, that's ruinous — and most of those tokens are numbers the model can't actually reason over anyway. Atlas does the work once on a structured engine and returns a few kilobytes of findings.

Fidelity. This is the one nobody talks about. Dumping a CSV into context is lossy — the model can't actually count rows, can't reliably sort, can't compute a histogram across 50M points. It pattern-matches. Atlas computes.

Concrete example. Imagine your agent receives a hosted Parquet file and the user asks "is there fraud in here?" A naive agent tries to load it, fails, and emits a confident-sounding wrong answer. An Atlas-powered agent:

1. Calls validate_dataset_source (free) to confirm the URL resolves.
2. Calls estimate_cost (free) to see a price ceiling.
3. Calls profile_dataset (paid, cheap) to learn it's 3.4M rows, 14 columns, with a merchant_id and a timestamp.
4. Calls query_dataset (paid) with a targeted filter — amount > 10000 AND timestamp > '2026-01-01'.
5. Calls research_dataset (paid, expensive) to chain those results into a written finding with charts.

Total cost: maybe two dollars. Total tokens burned by the agent: a few hundred. Total wrong answers: zero, because Atlas did the actual computation. That's the whole point of an AI dataset analysis MCP — moving the heavy lifting off the LLM and onto a tool that can prove what it ran.

Verifiable Analysis, Not a Black Box

The thing about any analysis service is that an agent — or its owner — has to trust it. We don't think you should have to. Every Atlas report ships with the same evidence trail the rest of EVIDIQ uses.

Here's the chain, end to end:

1. The Atlas worker computes the result deterministically where possible — profile stats, query results, chart specs.
2. The canonical evidence — inputs, tool version, parameters, outputs — is hashed with keccak256.
3. The hash is anchored on 0G Storage mainnet, returning a real on-chain tx your agent can re-fetch.
4. The signed report object is published as an artifact, retrievable by ID via get_artifact.
5. Anyone — the agent, the user, an auditor, a counterparty in a later dispute — can call verify_atlas_report, re-fetch the evidence, re-hash it, and confirm the EVIDIQ signer.

This is the same model we built EVIDIQ Sentinel and EVIDIQ Operator around: identity and capability probes get the same anchoring, the same signature, the same auditability. And for notarial sealing of the report itself, our EVIDIQ Notary docs walk through how a downstream system can elevate an Atlas finding into an evidentiary artifact without losing the chain.

The honest version: no analysis is "fully verifiable" if you can't independently re-run the same computation and get the same answer. We make that possible. The deterministic parts are deterministic. The LLM-narrated findings inside research_dataset carry their prompt and raw outputs alongside the narrative so you can inspect what the model was told. You may disagree with the narrative. You will not have to guess how it was produced.

If you're already using EVIDIQ's verify_agent to score an unknown counterparty, you can layer Atlas reports as reputation evidence — an agent that produces verifiable analysis is a measurably better counterparty than one that doesn't. Tools that lie can't be used as trust anchors. Tools that sign their work can.