Your agent just got handed a 47GB parquet dump of quarterly transactions. It needs to tell the user whether revenue is up or down, and why. What does it do? Most agents today will try to load chunks of it into context and pray. Tokens balloon, latency crawls, the answer gets hand-wavy by row 200,000 — and the user is left trusting a number that was effectively guessed.
We built EVIDIQ Atlas for exactly this moment. It's the AI dataset analysis MCP designed to let an agent call structured tools, get back real findings, and never have to ingest a 2GB CSV into its own head. If you're shipping agents in 2026, this is the layer you reach for when "let me just sample a few rows" is no longer acceptable.
What Is a Dataset-Analysis MCP?
EVIDIQ Atlas is the AI dataset analysis MCP we built as the data-side companion to our trust layer. It's an MCP server an agent connects to over the Model Context Protocol to profile, query, visualize, compare, and research datasets via tool calls, returning structured findings and signed artifacts instead of raw rows. Each call is metered via x402 and priced by analysis depth.
Think of it as the difference between asking a friend to "read this book and tell me the plot" versus handing them a one-page summary. The MCP server pattern is the same idea at machine speed — the agent tells Atlas what it needs, Atlas does the heavy work on real compute, and ships back evidence the agent can reason over and a human can audit.
In our 2026 stack, Atlas sits next to EVIDIQ Sentinel (which scores the trustworthiness of the agent you're about to transact with) and EVIDIQ Operator (which orchestrates runs and policy). Sentinel decides who to trust. Atlas decides what's actually in the data. Same protocol, same evidence model, same x402 payment rail.
Five Tools, Priced by Depth
Atlas exposes five paid tools and a handful of free helpers. The paid ones are metered per call via x402, settled on X Layer in USDT0, and the price scales with what you're asking the server to do. Cheap probes cost fractions of a cent. Heavy regressions cost more. Nothing is hidden behind a subscription wall — you pay for what you actually call, and every call is metered.
[IMAGE_PROMPT: A modern flat illustration showing a layered stack of five distinct tool cards arranged in a slight fan, each with a small data-themed icon (chart bars, magnifying glass, scatter plot, two overlapping pie charts, document with magnifier) and a price tag. A subtle x402 payment receipt icon hovers at the right. Color palette of deep teal, soft cyan, and warm orange on a clean off-white background. Developer/tech aesthetic, no text in the image.]
The five paid tools, in order of price:
- profile_dataset — the cheapest entry point. Returns schema, row count, null rates, type inference, basic stats. Enough to decide whether the dataset is even worth analyzing further.
- query_dataset — runs a structured query (SQL or pandas-style) against a snapshot and returns rows + an explanation. Costs more because compute actually spins up against a real engine.
- visualize_dataset — produces a chart artifact (PNG, plus the spec) you can render or attach. Priced higher than query because rendering plus asset anchoring isn't free.
- compare_datasets — two datasets, one verdict. Delta schemas, delta distributions, regression in metrics. The priciest standard tool because it does two profiles plus a diff.
- research_dataset — open-ended investigation. You hand Atlas a question, it plans the queries, runs them, and returns a written report. This is the heavy one, and the one you'll most often combine with the others.
Then the free helpers, which never cost anything:
atlas_capabilities— tells the agent exactly which tools exist, their schemas, and current prices.validate_dataset_source— checks whether a URL or CID is reachable and parseable before the agent spends a paid call on it.estimate_cost— given a proposed tool + parameters, returns the x402 price so the agent can budget.verify_atlas_report— re-fetches the anchored evidence, re-hashes it, and recovers the signer. Anyone can run this.get_artifact— pulls a previously generated chart or report by ID.
Why the tiering? Honestly? Because computing a column histogram is a different beast from running a cross-dataset regression. A flat per-call price punishes the cheap probes; a flat subscription punishes the rare heavy lift. Per-call x402 lets the agent price-shop its own work — and lets the owner see exactly what got spent and why, in the EVIDIQ docs. Our MCP server keeps the receipts.
Why an Agent Should Not Swallow a 2GB CSV
Here's the math. A 2GB CSV of plain text is roughly 500 million tokens. Even GPT-class context windows top out in the low millions, and Anthropic's largest is around a million. You're not loading it. You're summarizing it badly — and you don't even know which parts you're losing along the way.
What most agents actually do today: stream a few hundred rows, write a confident-sounding paragraph, and call it done. That's the failure mode the AI dataset analysis MCP stack at EVIDIQ was designed to kill.
Consider profile_dataset. An agent calls it with a pointer to a parquet file on 0G Storage. Atlas opens the file, walks the schema, computes type-aware stats, samples rows for null-rate and cardinality, and returns a tight JSON profile — usually under 4KB. The agent now knows the exact column types, null percentages per field, approximate distinct counts, distribution shape (skewed, bimodal, uniform), and a few sample rows per column.
It reasoned over a 4KB summary instead of trying to swallow 500M tokens. Token bill on the agent side: essentially zero. The answer is also more accurate, because the stats came from the full dataset, not a 200-row sample the LLM eyeballed. The user gets a real answer, not a confabulation dressed up as analysis.
Atlas can then chain calls. Profile → identify the interesting column → query_dataset with a specific slice → visualize_dataset for the user. The agent's context stays clean. The user gets a real chart, anchored on 0G Storage, with a hash they can verify. That's the design, and it scales to datasets of any size.
Verifiable Analysis, Not a Black Box
A chart from a black-box model is a vibes-based object. A chart from Atlas is evidence. The pipeline is built so that anyone — the calling agent, the human owner, an auditor — can independently confirm what was computed and against which version of the dataset. This is the same AI dataset analysis MCP standard we apply across the rest of the EVIDIQ stack.
[IMAGE_PROMPT: A modern flat illustration showing a horizontal data flow diagram: a stacked dataset icon on the left flowing through a central processing node (a stylized server with gears and a small verification badge) and emerging on the right as a signed report card with a cryptographic seal and a chain-link symbol. Below the flow, a row of three small icons representing 0G Storage, 0G Compute, and a verification checkmark. Color palette of deep blue, mint green, and gold accents on a soft gradient background. No text in the image.]
Every Atlas run produces a canonical report: the profile, query results, chart spec, and any AI commentary, normalized into a single JSON document. We hash that report with keccak256, anchor the hash on 0G Storage mainnet (returning an on-chain transaction), and sign the verdict with the EVIDIQ key under EIP-191. The agent receives the report and the receipt in the same response.
This is the same evidence model we use across the rest of EVIDIQ. EVIDIQ Sentinel anchors its trust score reports the same way. EVIDIQ Notary does it for arbitrary artifacts. The verify_agent tool inside the EVIDIQ MCP also returns anchored reports, and a developer can cross-check an Atlas report against a Sentinel report for the same session with a single call.
Worth noting: where the analysis is non-deterministic — say, the AI commentary around a chart — we still anchor the inputs and the prompt, and we run the commentary step inside a TEE on 0G Compute so the provider address and request ID are recorded. The agent or its owner can always say, "show me what was actually computed." That's the bar.
We've found this matters more than people expect. When an agent tells a user "your Q2 revenue dropped 14%," the user is going to ask "where did that number come from?" Atlas gives the agent a real, citable answer instead of a hedge — and the EVIDIQ Notary flow lets the same report be forwarded, re-anchored, and re-signed without losing provenance. Over time that becomes the actual asset: not the chart, but the signed trail of how the chart came to be.