ClickHouse AI vs Mitzu: An Open-Source Agentic Data Stack vs a Governed Analytics Platform on the Warehouse

Use this comparison if you are evaluating ClickHouse AI for analytics on ClickHouse and want to see how it differs from a governed analytics platform on the same warehouse: who writes the SQL, how metrics are defined, and what each runs beyond a chat answer.

ClickHouse has been calling itself an AI-first data warehouse, anchored by the Agentic Data Stack at clickhouse.com/ai and the AgentHouse demo. That makes "ClickHouse AI vs Mitzu" a fair question: both answer plain-English questions on ClickHouse data, and ClickHouse teams sit squarely in Mitzu's audience. ClickHouse AI is a general-purpose, open-source stack in which an LLM writes SQL on the warehouse. Mitzu is one analytics platform on the warehouse for BI, product analytics and experiment analysis, governed by the data team, with an AI agent whose SQL comes from a deterministic engine. ClickHouse is one of the warehouses Mitzu connects to.

What is ClickHouse AI?

ClickHouse AI is the umbrella name for ClickHouse's agentic offering. The public product page positions it as an "Agentic Data Stack" and an "Agent-native data stack": open-source pieces composed together, with ClickHouse for storage and query, LibreChat for the chat interface, Langfuse for traces and evaluation, and MCP for tool integrations. AgentHouse is the live demo of the stack.

The clearest reference implementation is DWAINE, ClickHouse's internal "Data Warehouse AI Natural Expert," documented on their company blog. Claude (via AWS Bedrock) writes SQL against ClickHouse, grounded by three MCP servers: ClickHouse itself, a GitHub-hosted business glossary and dbt docs, and a filesystem-based column dictionary. The blog post reports 250+ internal users and query errors that self-correct from database feedback, and describes non-technical users getting answers to business questions without writing SQL. Roughly 70% of the historic SQL workload moved into chat; 30% remains in Superset for certified financials and operational dashboards.

• No-code agents: build and share specialized agents across the team, from chat.
• Charts and dashboards from chat: visualizations are LLM-generated, not assembled from a typed methodology layer.
• MCP-extensible: connect to any tool that speaks Model Context Protocol; Shopify is cited running 30+ internal MCP servers.
• Langfuse observability: traces every agent workflow, scores outputs, monitors quality, cost and latency per LLM call.
• Open-source stack: every component is open source and deployable in your own infrastructure.

The architecture is general-purpose by design. The use cases on the public page span cancer genomics (cBioPortal), enterprise knowledge discovery (Shopify), product activation (Fetch / FAST) and employee-facing AI (Daimler Truck). It is not pitched at product analytics or experiment analysis, and the stack does not ship native funnel, retention, segmentation, cohort or experiment primitives. Methodology lives in whatever SQL the LLM produces.

What is Mitzu?

Mitzu is an analytics platform on your data warehouse for BI, product analytics and experiment analysis, where the data team governs the metrics and everyone uses them through dashboards, an AI agent, Slack and their own AI assistants. Like ClickHouse AI, it answers plain-English questions on ClickHouse data. Unlike ClickHouse AI, it is a finished product rather than a stack to assemble, and the same governed definitions also run KPI dashboards, funnels, retention, journeys and A/B test analysis.

The data team defines metrics such as net revenue, orders, average order value and margin once, on its own fact and dimension tables, and Mitzu can draft those definitions from the warehouse and dbt models for the data team to review. A Configuration Agent scans the warehouse for event and dimension tables, identifiers and property values. Every KPI dashboard, agent answer and scheduled agent reuses the same definitions, and each person sees only the data their Mitzu role allows. People reach Mitzu in the app, by mentioning @mitzu in Slack, through a remote MCP server from Claude, ChatGPT, Cursor, GitHub Copilot and other MCP clients, and through emails from scheduled monitoring agents that review dashboards and KPIs. ClickHouse is one of the supported warehouses, alongside Snowflake, BigQuery, Databricks, Redshift, PostgreSQL, Athena, Trino, Firebolt and Microsoft Fabric. See ClickHouse Analytics in 2026: Top 5 Product Analytics Tools.

The trust differentiator: Mitzu's agent does not write SQL. It assembles structured analysis specifications (a metric and its breakdown, funnel steps with a conversion window, retention cohorts and return events, segmentation filters with sampled property values, journey definitions, an experiment and its metrics) and a deterministic query engine turns those specifications into SQL. The same specification produces the same SQL every time. Methodology errors that LLMs reliably make, such as a funnel without a window, a retention chart that double-counts or a cohort defined wrong, are prevented by the engine rather than by prompt engineering.

ClickHouse AI vs Mitzu: side-by-side

SQL examples: the same question, two paths

A governed KPI question such as "What was net revenue last quarter?" works in both once revenue is defined. The difference shows on the product question that usually comes next: "What is our 7-day signup-to-activation conversion rate, broken down by acquisition channel, for the last 30 days?"

ClickHouse AI: SQL the LLM might generate

-- Plausible LLM output against a ClickHouse events table.
-- Looks reasonable; methodology depends on the prompt + grounding.
WITH signups AS (
  SELECT user_id,
         min(event_time)              AS signup_at,
         any(properties['channel'])   AS channel
  FROM events
  WHERE event_name = 'signup'
    AND event_time >= now() - INTERVAL 30 DAY
  GROUP BY user_id
),
activations AS (
  SELECT user_id, min(event_time) AS activated_at
  FROM events
  WHERE event_name = 'activated'
    AND event_time >= now() - INTERVAL 37 DAY
  GROUP BY user_id
)
SELECT s.channel,
       count()                                                       AS signups,
       countIf(a.activated_at <= s.signup_at + INTERVAL 7 DAY)       AS activated_in_7d,
       round(activated_in_7d / signups * 100, 1)                     AS conv_pct
FROM signups s
LEFT JOIN activations a USING (user_id)
GROUP BY s.channel
ORDER BY signups DESC;

Reads cleanly, but the methodology is doing a lot of work in the prompt. A different prompt run, or a slightly different schema, can yield a window measured against the wrong anchor, an activation that pre-dates the signup counted as a conversion, channel attribution joined off the wrong row when a user has multiple signups, or a window that quietly slips to 30 days because the LLM conflated the lookback with the conversion window. None of these are SQL bugs. They are methodology choices an LLM is making implicitly, every time.

Mitzu: SQL from a deterministic engine

The Mitzu agent does not write the SQL. It assembles a funnel specification, roughly { first_event: "signup", subsequent_events: ["activated"], conversion_window: "7d", breakdown: "channel", date_range: "last_30_days" }, and the deterministic engine emits the same SQL every time:

-- Engine output for a 2-step funnel with a 7-day conversion window,
-- broken down by channel, for the last 30 days. Same spec → same SQL.
WITH step_1 AS (
  SELECT user_id,
         min(event_time)             AS step_1_at,
         any(properties['channel'])  AS channel
  FROM events
  WHERE event_name = 'signup'
    AND event_time >= now() - INTERVAL 30 DAY
    AND event_time <  now()
  GROUP BY user_id
),
step_2 AS (
  SELECT s1.user_id,
         s1.channel,
         min(e.event_time) AS step_2_at
  FROM step_1 s1
  INNER JOIN events e
    ON e.user_id = s1.user_id
   AND e.event_name = 'activated'
   AND e.event_time >  s1.step_1_at
   AND e.event_time <= s1.step_1_at + INTERVAL 7 DAY
  GROUP BY s1.user_id, s1.channel
)
SELECT s1.channel                                AS channel,
       count(DISTINCT s1.user_id)                AS step_1_users,
       count(DISTINCT s2.user_id)                AS step_2_users,
       round(count(DISTINCT s2.user_id)
             / nullIf(count(DISTINCT s1.user_id), 0) * 100, 1) AS conv_pct
FROM step_1 s1
LEFT JOIN step_2 s2 USING (user_id)
GROUP BY channel
ORDER BY step_1_users DESC;

The conversion window is enforced strictly (activation must be after signup and within 7 days). Distinct users prevent double-counting. Channel comes from the signup row, so attribution is consistent. The engine has been generating this shape of SQL in production for years; the agent's job is to assemble the specification, not to author the query.

The SQL is shown to the analyst as a verification artifact, not as the agent's authored work, and the funnel can sit on the same dashboard as the revenue KPI it explains.

Advantages and trade-offs

ClickHouse AI

Mitzu

Capability scorecard

Where each tool stands on governed metrics and BI, on product analytics and experiment analysis, and on how people reach the agents.

When to choose ClickHouse AI, Mitzu, or both?

Both answer plain-English questions on ClickHouse data, so they overlap. The ClickHouse AI stack gives you a general agentic interface to the warehouse that you assemble and run, with an LLM writing the SQL. Mitzu gives you one analytics platform where the same governed definitions run KPI dashboards, product analytics and experiment analysis, with a deterministic engine that keeps the methodology right. The right choice depends on which questions dominate the team's workload and how much the answers have to agree with each other.

• Choose ClickHouse AI when the questions are broad and free-form across domains, you want full control of an open-source stack, and you have the engineering cycles to assemble and maintain LibreChat, Langfuse, MCP servers and grounding docs.
• Choose Mitzu when you want KPI dashboards plus funnels, retention, journeys and A/B test results on one set of definitions the data team governs; an agent that explains why a number moved (why did week-2 retention drop, did the new pricing page move trial-to-paid, which onboarding step has the highest drop-off) with SQL from a deterministic engine; scheduled agents that watch the KPIs; and the same answers in Slack and AI assistants.
• Run both when an internal ClickHouse AI deployment already serves engineers and analysts for ad-hoc questions, and the data team wants governed KPI reporting, product analytics and experiment analysis for the rest of the company on the same ClickHouse cluster.

FAQ

Does Mitzu work with ClickHouse?

Yes. ClickHouse is a first-class supported warehouse. Mitzu reads event, fact, dimension and dbt-modeled tables in place, with no data movement and no per-event pricing. See ClickHouse Analytics in 2026: Top 5 Product Analytics Tools for the broader landscape.

Does ClickHouse AI replace Mixpanel, Amplitude or other product analytics tools?

Not by itself. ClickHouse AI is general-purpose agentic analytics on warehouse data. For product analytics methodology specifically (funnels with conversion windows, retention cohorts, journey trees, segmentation with sampled filter values) and for experiment statistics, you either use a platform like Mitzu, where that methodology is built into the engine next to the KPI dashboards, or build it yourself in SQL and rely on the LLM to compose it correctly each time.

Can I use ClickHouse AI for funnels and retention?

An LLM can write a funnel or retention query against ClickHouse. Whether the methodology is right depends on the prompt, the grounding, and the day. The risk is not that the SQL fails to run (it usually runs) but that it answers the wrong question: a window measured wrong, double-counted users, attribution joined off the wrong row. A deterministic engine that owns the methodology removes that class of error.

Is Mitzu open source?

No. Mitzu is a commercial SaaS product. The Enterprise plan supports self-hosted deployment in the customer's own infrastructure. Every plan includes Editor seats and unlimited events, with no per-event pricing; see the pricing page for current details.

Where does the data live in either tool?

In your warehouse. Both architectures are warehouse-native: ClickHouse AI by composition (the stack reads ClickHouse directly), Mitzu by design (the agent reads the warehouse through the deterministic engine). Neither moves data into a vendor silo. Compliance, data residency and cost control all stay on your side of the line.

Related reading

• ClickHouse Analytics in 2026: Top 5 Product Analytics Tools
• ChatGPT vs AI Analytics Agent
• Warehouse Native vs First-Generation Product Analytics
• Agentic Analytics Platforms Compared
• Mitzu BI and Warehouse Metrics
• Mitzu Experiment Analysis
• Mitzu Semantic Layer
• Mitzu Product Analytics

References

• ClickHouse: Agentic Data Stack (clickhouse.com/ai)
• ClickHouse blog: The AI-first data warehouse (DWAINE case study)
• LibreChat
• Langfuse
• Model Context Protocol
• Mitzu documentation (docs.mitzu.io)