Do We Really Need to Build AI Agents for Data?

A new category of product is emerging: the AI data agent. Specialized systems that promise to import your data, analyze it, and present the results — all through an intelligent, purpose-built agent experience.

We think this is solving the wrong problem.

The Software Already Exists

Data work has followed the same three-step flow for decades:

1. Import the data
2. Analyze the data
3. Present the data

And the software for every step is not just built — it is excellent.

Import. dbt, Airbyte, Fivetran, Singer, Apache Spark, custom ETL scripts — the data ingestion ecosystem is enormous. You can pull from CSVs, APIs, data lakes, warehouses, or streaming sources. Connectors exist for virtually every data source on earth.

Analyze. DuckDB can query billions of rows on a single machine with zero setup. pandas and polars handle in-memory transformations. SQL is universal. Jupyter notebooks combine code, output, and narrative in one place. R has decades of statistical methods built in. These tools are not toys — they power production analytics at the largest companies in the world.

Present. D3.js produces some of the most beautiful data visualizations ever made. Plotly and Vega-Lite generate interactive charts with a few lines of code. Observable, Streamlit, and Gradio turn scripts into shareable dashboards. Matplotlib and seaborn are ugly but infinitely flexible. The charting and visualization ecosystem is vast, mature, and capable of producing genuinely stunning output.

These tools have been refined over 20+ years. The primitives are not missing. They never were.

The only reason people think we need specialized data agents is that the existing software is hostile to most users.

The Real Problem Was Always UX

The tools work. The problem is that using them requires deep technical knowledge at every step.

1. Import the data — configure dbt models, write ingestion scripts, set up database schemas, manage credentials, handle data type conversions. Requires SQL, DevOps knowledge, and often a data engineer.
2. Analyze the data — write Python scripts, construct SQL queries, build transformation pipelines, validate statistical assumptions, handle edge cases. Requires programming skills and domain knowledge.
3. Present the results — choose the right chart type, configure D3 or Plotly, style a dashboard, handle responsive layouts, deploy it somewhere accessible. Often requires a frontend developer.

Three steps. Three different skill sets. Most people cannot do even one of them without help.

That is why companies hire data teams — not because the software does not exist, but because nobody else can use it. The UX wall is the entire problem.

AI Agents Fix the UX Layer

This is the shift. A general-purpose coding agent — given a cloud computer and standard tools — can operate all of that software on the user's behalf. It knows SQL. It knows Python. It knows dbt, DuckDB, pandas, D3, Plotly, and a hundred other tools. It already understands the software that took engineers years to learn.

The user just says what they want in plain language. The agent does the rest.

No specialized "data brain" needed. No custom query planner. No proprietary analysis engine. Just a capable coding agent and the same primitives engineers have used for years.

A Real Example: The Superstore Dataset

Consider a concrete scenario. You have a Superstore dataset — roughly 10,000 records of retail transactions with columns for sales, profit, category, region, shipping, and discounts. A typical data analysis workflow looks like this:

1. Understand and raise the question. What do you actually want to know? Which categories are most profitable? Do discounts help or hurt margins? Is furniture underperforming? Formulating the right questions is the hardest part — and it is where most analysis projects stall.
2. Analyze to verify assumptions. For each question, write SQL queries or Python scripts. Run them, inspect the output, check for edge cases, re-run with different parameters. This is iterative, tedious, and requires both technical skill and domain intuition.
3. Present the results. Turn raw query output into something a human can read — tables, charts, a report with clear verdicts. This is where most people give up entirely.

Now watch what happens when an AI coding agent handles each step.

1. Raising the questions

A human might come up with three assumptions to test. An agent can generate dozens. It reads the schema, samples the data, and produces a comprehensive list of hypotheses — spanning profitability by category, discount impact, regional patterns, shipping efficiency, and customer segmentation. It explores whatever it wants, limited only by time, not imagination. It does not get tired or run out of ideas.

2. Running the analysis

For each assumption, the agent writes SQL queries against DuckDB, runs them, inspects the results, and iterates. If a query reveals something unexpected, it digs deeper — adding breakdowns, computing correlations, running follow-up queries. It does not need permission to explore. It just works through the data the way a senior analyst would, except it can do it for a hundred assumptions in the time a human would finish three.

3. Presenting the results

This is where the agent often surprises people. Given the raw analysis, it produces a styled HTML report — complete with verdict badges, formatted data tables, syntax-highlighted SQL queries, and a clear narrative for each finding. It added a bonus shipping analysis on its own initiative. The output is not a raw CSV dump. It is a document you could send to a stakeholder.

View the full interactive report

One prompt. No special data skill installed. No workflow configured. The agent had a cloud computer with DuckDB — the same tool any data engineer would use — and it did the job better than most humans could in a fraction of the time.

Why General Agents Beat Specialized Ones

Specialized data agents are optimized for a narrow idea of how analysis should happen. That sounds appealing, but it creates a ceiling. The moment the task goes beyond the agent's built-in workflow, you are stuck.

A general coding agent has no ceiling. It can:

• Write SQL, Python, R, or JavaScript — whatever the task requires
• Switch from DuckDB to pandas to a Jupyter notebook mid-analysis
• Install any library it needs — Plotly, seaborn, scikit-learn, dbt
• Build a one-off script or a reproducible pipeline
• Generate a static report, an interactive D3 dashboard, or a raw CSV
• Adapt when the question changes halfway through

It works the way a senior data engineer works — flexibly, using the right tool for the job, not locked into one pattern.

Our Verdict

You do not need to build specialized data agents. You need to give general AI agents the primitives.

A cloud computer. DuckDB. Python. A charting library. Standard, mature tools that have been refined for decades.

The agents will use them better than any specialized system — because they are not constrained by a product designer's assumptions about how data work should happen. They can explore more broadly, analyze more deeply, and present more beautifully than any rigid workflow allows.

The primitives were always there. The only thing that was missing was someone — or something — that could actually use them. Now that barrier is gone.

Less structure. More tools.

What This Does Not Solve

There is one hard problem that no AI agent — specialized or general — has cracked yet: the data semantic layer.

An agent can write perfect SQL. It can build beautiful charts. But it does not know that revenue in your company means gross revenue minus returns, not net revenue. It does not know that active_user means someone who logged in within the last 30 days, not 90. It does not know that Q4 numbers should exclude the subsidiary you divested in October.

This is enterprise and organizational knowledge — the meaning behind the columns, the business rules that never made it into the schema, the context that lives in people's heads. No amount of SQL fluency compensates for not knowing what the data actually means.

This is the genuinely hard problem in AI-powered data work. And it is what we will write about next: how to extract human knowledge about data semantics and feed it to AI agents so they can reason about your data the way your team does.