Introducing Agentic GenBI: A Chat Box Answers a Question. An Agent Does the Work.

For two years the industry sold you a chat box and called it AI for analytics. I watched dozens of these demos, and they all die at the same moment: the second question.

You ask "what was revenue last month," and it works. You ask "now break that down by the segments we actually care about," and it falls apart. The agent forgot the first answer, and it never knew what "revenue" meant to your company in the first place.

That second question is where I've spent the last year of my life. It's why we rebuilt Wren AI from the ground up, and it's why we're calling what we built something different: Agentic GenBI.

A chat box answers a question. An agent does the work. The difference isn't a better model. It's a system that reasons in steps, remembers what it learns, and stays inside your governance the entire time.

Why "chat with your data" keeps failing

The "chat with your data" pattern is a thin language model stapled to a schema. It reads your column names, guesses at joins, and writes SQL. When the question is simple, it looks like magic. When the question is real, four things break at once.

It has no semantics. Revenue is a business definition, not a column. It lives in calculations, in exclusions, in the difference between booked and recognized. A model reading raw table names will hallucinate a join and hand you a confident wrong number. This is the gap I've written about before: the missing layer for AI over business data isn't access, it's understanding.

It has no memory. Every session starts from zero. The correction you made yesterday, the metric definition your analyst pasted in last week, the way your team always filters out internal test accounts: all gone. A human analyst accumulates this. A stateless chatbot throws it away every time.

It can't do multi-step work. Real analysis isn't one query. It's pull the data, reconcile two sources, chart it, lift a number out of a contract PDF, and assemble the result. A single text-to-SQL call can't hold a plan across those steps.

Governance is bolted on at the UI. When the chatbot is the only door, row and column security gets enforced at that one door. The moment another agent hits the same data (Claude, Cursor, an internal copilot), the policy isn't there.

None of these are fixed by waiting for a smarter model. They're architecture problems. And notice what they have in common: the thing missing isn't a smarter model, and it isn't even a semantic layer. A semantic layer gives you trusted definitions, which fixes the first failure. It says nothing about the other three. What an agent actually needs is a context layer — a superset of the semantic layer. Semantics is one slice. The agent also needs to know which definitions are trusted, which joins are allowed, what your team corrected last week, and when to stop and ask. So we treated all of it as architecture.

What Agentic GenBI actually is

The shift is simple to state and hard to build. The unit of BI is no longer the dashboard or the query. It's an agent reasoning over a governed context layer.

Here is the loop, and each piece is something we shipped, not something we promised.

1. Agentic Design: sandboxed, multi-step reasoning. The agent doesn't just generate one SQL string. It works in an isolated environment where it can use tools and write scripts: query a warehouse, chart a result, extract a figure from a PDF, build a dashboard, and save what it learned as a skill. Every step is traceable. The sandbox means the agent can do real work without touching production directly.

2. A semantic model at the core of the context layer. The reasoning is only trustworthy because it runs on top of MDL, our modeling definition language. One definition of "revenue" lives in a file, and the agent reasons over that instead of inventing joins from raw schemas. MDL is the semantic slice; the operational rules and learned patterns wrap around it. This is the same Rust and Apache DataFusion engine we rebuilt last year, now carrying an agent instead of a dashboard.

3. Skills and Memory: context that compounds. Skills are SOPs for your agent: codified workflows that produce consistent output instead of a fresh guess each time. Memory turns past interactions, preferences, and corrections into institutional knowledge. The second question works because the agent kept what it learned from the first. This is the part the chatbots structurally cannot do.

4. GenBI Apps: the dashboard becomes disposable. You describe what you need, and one prompt renders a polished, context-layer-governed dashboard. No SaaS click-through to pick fields, no BI learning curve, no analyst ticket. The dashboard stops being the artifact you maintain for two years. It becomes output you regenerate whenever the question changes.

The part most people miss: this is for agents too

We named it "Agentic GenBI for Humans and Agents" on purpose.

The same governed answer has to hold whether the caller is a person in the UI, a script hitting the API, or Claude reaching in over MCP. So we enforce row-level and column-level security at execution, not at the interface. One policy, every consumer. Agent-agnostic on the way in, governed on the way out.

That changes what your data team does. Skills, Memory, the Semantic Model, and the agent's instructions are all files: version-controlled, branched, PR-reviewed, rolled back. Git-native. Together those files are the context layer. Your team stops fielding ad-hoc query tickets and starts curating the context the agent reasons over. They become context architects, not a SQL help desk.

We also Open-sourced the core

Think about what the semantic model actually is. It's the definition of revenue, the entity relationships, the joins your finance team would go to war over. If an agent reasons over that to produce numbers people act on, you need to see exactly how it reasons. You need to fork it, audit it, run it on your own infrastructure.

So Wren AI core is open source on GitHub. What you get is the open context layer for AI agents: the MDL semantic contract that defines your models, relationships, and calculated fields; the Rust engine on Apache DataFusion that plans SQL across 20-plus sources; a CLI for querying, validation, and profiling; the agent Skills that codify safe operations; and SDKs that drop straight into LangChain or Pydantic AI. The 15,000 stars and 50,000 users didn't come from a marketing push. They came from data engineers who could read the code, run it locally against their own Postgres or BigQuery, and verify it before trusting it with anything real. For a layer that's supposed to be ground truth for AI over data, open is the only way it earns that trust.

Founders ask me how the open-source and commercial sides fit together, so here's the honest line. We open-source the thing you'd never accept as a black box, and we charge for running it at scale. The core stays free: model your data in MDL, give the agent skills, query in place across your warehouses, self-host it forever. The commercial product is the operational and behavioral weight on top of that: governed join paths and access rules enforced at execution, memory that compounds from your team's corrections and feedback, the hosted infrastructure, SSO, the embedded API for putting GenBI inside your own product, and the support and SLAs a team needs once this is load-bearing.

Where this goes

Old way: a human learns the BI tool, files a ticket, waits, and maintains a dashboard nobody fully trusts. New way: an agent does the work over a context layer your team owns, and gets better every time it's used.

I think three years out, the dashboard is disposable and the durable asset is your context layer: the metric definitions, the skills, the memory, all version-controlled and compounding. The company that owns its context owns its business logic. Everything else is just execution.

A chat box answered a question. We were never going to win by building a better chat box. We built the thing that does the work, we made it agentic, and we put the core in your hands to read, run, and own.