Picture this: your agent has just been handed a 4.3GB CSV of customer transactions and a one-line prompt — "find the churn pattern." What happens next? If it's a typical LLM, it'll either choke on the size, sample randomly and miss the signal, or burn through tens of thousands of tokens just to count nulls. None of those are good outcomes.
We built EVIDIQ Atlas because agents shouldn't have to ingest data to understand it. Atlas is our AI dataset analysis MCP — a metered tool server that lets an agent ask sharp questions of a dataset and get back structured, evidence-anchored answers. No full ingest. No black-box summaries. No surprise bill at the end of the month.
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 a dataset through tool calls instead of loading the entire file into context. EVIDIQ Atlas is our dataset-analysis MCP, priced per call via x402, returning structured, verifiable findings and artifacts.
In practice, an AI dataset analysis MCP acts like a data analyst on call. The agent sends a dataset reference — usually a URL, CID, or path — and a question. Atlas profiles it, runs the analysis, returns a JSON report plus any artifacts (charts, summaries, diffs), and signs the result so the agent can prove what it learned. The agent never sees the rows; it sees the conclusion.
Here's the thing: there are plenty of MCP servers that wrap a SQL engine or a Pandas shell. What makes Atlas different is the pricing model, the verification chain, and the fact that we treat every report as evidence — not just an answer. If you want the full surface area of EVIDIQ's broader trust stack, the EVIDIQ docs walk through Sentinel, Operator, Notary, and Atlas side by side.
Five Tools, Priced by Depth
Atlas ships five paid analysis tools and a handful of free helpers. The paid tools are tiered by how much compute they actually use, which is why deeper analysis costs more per call.
The paid lineup:
- profile_dataset — schema, row count, types, nulls, basic stats. Cheap, fast, and the right starting move for any new file.
- query_dataset — natural-language or structured query against the dataset, returning rows or aggregates with row caps.
- visualize_dataset — generates charts (histograms, scatter, time series) as standalone artifacts the agent can paste into a report.
- compare_datasets — diffs two datasets on schema, distribution, or a user-defined metric. Useful for "is the new cohort different?" questions.
- research_dataset — the heavy hitter. Multi-step reasoning over the data with hypothesis testing and a written analysis. This is the one that actually thinks.
[IMAGE_PROMPT: A modern flat illustration showing a stylized MCP server icon connecting to a floating dataset card with chart artifacts — bar chart, scatter plot, and histogram — flowing outward as signed receipts with hash seals. Developer/tech aesthetic with cool blues, teal accents, and a soft gradient background. No logos, no text in image, abstract geometric shapes only.]
The free helpers round it out:
- atlas_capabilities — discovery: returns the tool list and current pricing so the agent knows what's available.
- validate_dataset_source — checks a URL, CID, or path is reachable and matches declared metadata.
- estimate_cost — given a tool and dataset hint, returns the expected x402 price before you commit a single call.
- verify_atlas_report — re-hashes an Atlas report and confirms the EVIDIQ signature against the on-chain anchor.
- get_artifact — fetches a chart, CSV slice, or full report by id without re-paying for analysis.
Every paid call returns a 402 challenge with accepts[].amount in USDT0, settled on X Layer via EIP-3009 transferWithAuthorization. Cost scales with depth: profile_dataset is a few cents, research_dataset is the price of a coffee because it actually runs reasoning over your data. Honestly? That feels fair — you're paying for the work, not the brand.
For context on how Atlas fits into EVIDIQ's broader verification story, the EVIDIQ Notary docs explain the same evidence pipeline that anchors Atlas reports.
Why an Agent Should Not Swallow a 2GB CSV
Let's talk about the failure mode we're actually solving. Token cost is the obvious one — pushing a 2GB CSV through a context window at, say, $3 per million output tokens is a fast way to ruin an afternoon. But the deeper problem is lossiness.
When an LLM "sees" a large CSV through chunking, it doesn't see the distribution. It sees fragments. It can tell you column names. It can give you a vibe. It cannot tell you that column 14 has a bimodal distribution with a suspicious spike at zero, or that rows 800,000–812,000 are silently duplicated. Those are exactly the findings that change a decision.
Take profile_dataset. The agent calls it with a CID. Atlas returns a JSON profile: schema, dtypes, null counts, min/max, percentiles, cardinality hints, and a few "interesting" flags — like a column whose top value accounts for 92% of rows, or a date column whose min is in 1970. The agent now has a map of the territory. It can decide what to query next, what to visualize, what to ignore. Total tokens on the agent side: maybe 400.
Compare that to shoving the CSV into context: millions of tokens, several minutes of inference, and the model is still guessing. The math is simple — don't pay context-window prices for what a profiler can deliver in a few hundred tokens. As we put it when designing Atlas: an AI dataset analysis MCP is what you call when you want the agent to know the data, not swallow it.
If the agent needs a deeper question answered, it can chain tools — profile first, then query on the suspicious column, then visualize, then research_dataset for a written analysis. Each step is paid for independently and produces signed evidence the agent can show its user. No surprise bill. No opaque summary. Just receipts.
Verifiable Analysis, Not a Black Box
Trust is the part most data tools skip. Atlas does not.
Every report is deterministic where it can be. Given the same dataset and parameters, profile_dataset returns the same profile. query_dataset returns the same rows. That alone is rare — most "AI data analyst" tools are vibes-driven. We built the core profiling and querying layers to be reproducible, so an auditor can rerun the call and get the identical artifact, byte for byte.
Then we anchor the evidence. The canonical report is hashed with keccak256, stored on 0G Storage mainnet (which returns an on-chain transaction), and optionally run through 0G Compute with GLM-5.2 inside a TEE for a second-pass risk analysis. The verdict is signed with the EVIDIQ key under EIP-191, and the signature, hash, and 0G tx are bundled into the report itself.
What does that buy you?
- The agent can hand the report to its user and say "this is what I learned, here's the proof."
- The user can re-fetch the artifact from 0G, re-hash it, and recover the signer.
- A regulator (eventually) can audit the trail without trusting EVIDIQ as a custodian.
This is the same evidence model our trust-score products use. The EVIDIQ Sentinel docs cover the live probe that checks whether an agent's endpoint actually serves what it claims. The EVIDIQ Operator docs cover the orchestration layer that ties Atlas calls into a multi-agent workflow. Atlas — our AI dataset analysis MCP — is the data-analysis leg of that same chair, and EVIDIQ treats the trust score and the dataset score as first-class siblings — both auditable, both signed, both anchored on chain.
[IMAGE_PROMPT: A modern flat illustration depicting a layered verification stack: bottom layer a stylized dataset file icon, middle layer a compute engine inside a TEE shield with a lock symbol, top layer a signed receipt with a hash code and a stylized on-chain transaction block. Connected by upward arrows. Soft gradient background with indigo and cyan tones. No logos, no text in image.]
One opinionated take worth saying out loud: an analysis you cannot re-verify is just an opinion. In 2026, with agents making purchasing and hiring decisions on top of data we didn't choose, "trust me" isn't a workflow. Atlas is our answer to that.