Amplitude AI Agents vs Mitzu: Vendor-Silo Agentic Analytics vs Warehouse-Native Agentic Product Analytics

Use this comparison to evaluate Amplitude's agentic analytics through a warehouse-native lens: what changes when the agent sees your dbt models, your billing tables and your CRM data — not just the events you forwarded into a vendor silo.

In February 2026 Amplitude introduced Amplitude AI Agents — a Global Agent for natural-language analytics plus a set of specialized agents around dashboard monitoring, session replay, web experimentation and feedback. The era where "agentic analytics" meant text-to-SQL bolted onto a BI tool is over; the incumbent product analytics platforms have agents of their own. The interesting question for ClickHouse-, Snowflake- and BigQuery-using teams is no longer do they have AI, but what data does the AI see. Amplitude's agents run inside Amplitude's behavioural data store. Mitzu's agent runs on your data warehouse. Same broad category — agentic product analytics — different architecture under the hood, different questions each tool answers cleanly.

What is Amplitude AI Agents?

Amplitude AI Agents is the umbrella name for the agentic surface on top of Amplitude's analytics platform, announced in February 2026. The flagship is the Global Agent — a chat surface that analyses data, builds dashboards, investigates root causes, and recommends actions across funnels, experiments, segments and customer journeys. Around it sit four specialized agents focused on particular workflows.

• Global Agent — natural-language Q&A across Amplitude data; explains what changed and why, builds dashboards, segments users, maintains the event taxonomy.
• Dashboard Monitoring Agent — watches metrics, detects shifts within hours, and delivers investigations to Slack or email.
• Session Replay Agent — reviews user sessions, identifies friction, quantifies revenue impact, and proposes fixes.
• Web Experimentation Agent — designs and launches experiments, analyses results, and requests human approval before rollout.
• AI Feedback Agent — converts unstructured survey and support feedback into themes linked back to behavioural cohorts.

The agents draw on what Amplitude itself stores: behavioural events, session replays, experiments, guides, surveys, and the event taxonomy maintained inside the product. The architecture page describes a "rich semantic model" built from "event taxonomies, charts, dashboards, experiments, flags, and governance metadata," and notes the underlying model layer uses systems from OpenAI, Google and Anthropic plus "homegrown backends for orchestration, memory, session storage." Amplitude also exposes a Model Context Protocol server so external agents — Claude, Cursor, ChatGPT and others — can read Amplitude data through an MCP-compatible client.

The architecture is a natural extension of Amplitude's first-generation model: events are captured by Amplitude SDKs (or forwarded by a CDP), stored in Amplitude's columnar backend, and analysed there. The agents are now another layer of analysis over that same data. Anything the agent can answer is anchored in what has been ingested into Amplitude.

What is Mitzu?

Mitzu is an agentic product analytics platform that runs on your data warehouse and answers behavioural questions through natural-language conversation, without writing SQL. The category is narrower than general agentic analytics — Mitzu is specialised for product, growth and marketing behavioural questions on event data — and the architectural choice that defines the rest of the product is that event data stays in the customer's warehouse.

Setup is handled by a Configuration Agent that scans the warehouse, recognises common event schemas (Segment, Snowplow, Firebase, GA4, custom event tables, dbt-modelled tables), maps user and group identifiers, and builds the semantic layer automatically. Mitzu meets users in three places: the in-app Analytics Agent, the Slack Agent in any public or private channel, and a remote MCP server that exposes Mitzu's capabilities to any MCP-compatible agent (Claude, Cursor, ChatGPT, custom). All three surfaces share the same semantic layer and methodology engine. See Warehouse Native vs First-Generation Product Analytics for the broader architectural picture.

The trust differentiator: Mitzu's agent does not write SQL. It assembles structured analysis specifications — funnel steps with a conversion window, retention cohorts and return events, segmentation filters with sampled property values, journey definitions — 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 (a funnel without a window, a retention chart that double-counts, a cohort defined wrong) are guard-railed by the engine, not by prompt engineering.

Amplitude AI Agents vs Mitzu: side-by-side

Strengths at a glance

SQL examples: where warehouse-native shows up

Both tools handle a classic funnel question cleanly. Where the architectural difference becomes visible is the moment a question needs data that lives outside the events table. Take a question marketing leaders ask constantly: "7-day signup-to-activation conversion by acquisition channel, weighted by 30-day revenue from billing." Amplitude can answer the first half — funnel by channel. The revenue join is where the vendor silo ends and the warehouse begins.

Amplitude: the funnel part

Amplitude's Global Agent does not expose user-facing SQL — methodology is encoded in their internal funnel engine. A user asks the question in chat; the agent returns a funnel chart with the 7-day window enforced and channel as the breakdown. Conceptually, the underlying operation is roughly equivalent to:

-- Conceptual shape of what Amplitude's engine computes for the funnel half
-- of the question, scoped to the events that have been ingested into Amplitude.
-- Channel attribution comes from Amplitude's own ingestion / taxonomy.
WITH signups AS (
  SELECT amp_user_id,
         min(event_time)               AS signup_at,
         any(initial_utm_source)       AS channel
  FROM amplitude_events
  WHERE event_type = 'signup'
    AND event_time >= now() - INTERVAL 30 DAY
  GROUP BY amp_user_id
),
activations AS (
  SELECT s.amp_user_id,
         s.channel,
         min(e.event_time) AS activated_at
  FROM signups s
  JOIN amplitude_events e
    ON e.amp_user_id = s.amp_user_id
   AND e.event_type  = 'activated'
   AND e.event_time  >  s.signup_at
   AND e.event_time  <= s.signup_at + INTERVAL 7 DAY
  GROUP BY s.amp_user_id, s.channel
)
SELECT s.channel,
       count(DISTINCT s.amp_user_id)                                       AS signups,
       count(DISTINCT a.amp_user_id)                                       AS activated_in_7d,
       round(count(DISTINCT a.amp_user_id)
             / nullIf(count(DISTINCT s.amp_user_id), 0) * 100, 1)           AS conv_pct
FROM signups s
LEFT JOIN activations a USING (amp_user_id)
GROUP BY s.channel
ORDER BY signups DESC;

The methodology is correct because Amplitude's engine enforces the window and the breakdown. The boundary is the data: amplitude_events contains only what has been forwarded into Amplitude. The 30-day revenue join — which lives in the billing system or in a Stripe-modelled dbt table — is not in scope unless that revenue stream has been pushed into Amplitude as events.

Mitzu: funnel + warehouse-native revenue join

Mitzu 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 SQL that joins the funnel output to the billing dimension table modelled in the warehouse:

-- Engine output: 7-day signup-to-activation funnel by channel,
-- joined to a warehouse-modelled billing table for 30-day revenue.
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
),
revenue_30d AS (
  SELECT b.user_id,
         sum(b.amount_usd) AS revenue_usd
  FROM dim_billing b
  WHERE b.charged_at >= now() - INTERVAL 30 DAY
  GROUP BY b.user_id
)
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,
       coalesce(sum(r.revenue_usd), 0)                     AS revenue_30d_usd
FROM step_1  s1
LEFT JOIN step_2      s2 USING (user_id)
LEFT JOIN revenue_30d r  USING (user_id)
GROUP BY channel
ORDER BY revenue_30d_usd DESC;

Conversion methodology is identical to Amplitude (strict window, distinct users, channel from the signup row), but the join to dim_billing happens in the same SQL pass because Mitzu reads the warehouse directly. The billing table never leaves the warehouse and the agent never had to author this join — the deterministic engine produced it from the analysis specification and the semantic layer's knowledge of which entities are joinable.

Retention: cohort definition, same shape

Retention is another methodology primitive both tools handle natively. Mitzu's engine produces SQL like this for the question "week-2 retention for users acquired via paid channels, by signup week, for the last 12 weeks":

-- Engine output for a weekly retention chart, cohorted by signup week,
-- with a 'paid' channel filter resolved against sampled property values.
WITH cohorts AS (
  SELECT user_id,
         min(event_time)                              AS signup_at,
         date_trunc('week', min(event_time))           AS cohort_week,
         any(properties['channel'])                   AS channel
  FROM events
  WHERE event_name = 'signup'
    AND event_time >= now() - INTERVAL 12 WEEK
  GROUP BY user_id
),
filtered AS (
  SELECT *
  FROM cohorts
  WHERE channel IN ('paid_search', 'paid_social', 'paid_display')
),
returns AS (
  SELECT f.cohort_week,
         count(DISTINCT f.user_id)              AS cohort_size,
         count(DISTINCT CASE
           WHEN e.event_time >= f.signup_at + INTERVAL 14 DAY
            AND e.event_time <  f.signup_at + INTERVAL 21 DAY
           THEN f.user_id END)                  AS week_2_returners
  FROM filtered f
  LEFT JOIN events e
    ON e.user_id = f.user_id
   AND e.event_time > f.signup_at
  GROUP BY f.cohort_week
)
SELECT cohort_week,
       cohort_size,
       week_2_returners,
       round(week_2_returners / nullIf(cohort_size, 0) * 100, 1) AS retention_pct
FROM returns
ORDER BY cohort_week;

The filter values paid_search, paid_social and paid_display come from the semantic layer's sampled property values, not from the agent guessing what your channel labels look like. The week-2 window is defined as the 7-day band starting 14 days after signup — not the loose "sometime in week 2" interpretation an LLM might pick. Same specification, same SQL, same answer.

Advantages and trade-offs

Amplitude AI Agents

Mitzu

Where the agent meets the user?

The two tools also meet users in different places. Amplitude's Global Agent lives inside Amplitude's web app — questions are asked next to the charts, dashboards and experiments the team has built up over time, with specialized agents posting investigations and digests to Slack and email. Amplitude's MCP extends that surface outward, letting Claude, Cursor, ChatGPT or any MCP-compatible client read Amplitude data on demand.

Mitzu meets users in three surfaces over the same warehouse-native semantic layer. The in-app Analytics Agent is a chat interface inside Mitzu, with full access to saved insights, dashboards, cohorts and the semantic layer. The Slack Agent answers @mitzu mentions in any public or private channel, with thread context shared with the agent — used heavily by adjacent personas (PMs, marketing, leadership) who never open the app. The Remote MCP server exposes Mitzu's capabilities to any MCP-compatible external agent, so a Claude or Cursor workflow can pull product analytics from Mitzu without leaving its native surface. See Agentic Analytics Platforms Compared for a broader survey of the agent surface area across vendors.

When to choose Amplitude, Mitzu, or both?

These are not interchangeable tools and the right answer often depends on where the rest of the stack sits. The architectural fork — vendor silo vs warehouse — drives everything downstream.

• Choose Amplitude AI Agents when the team is already deep in Amplitude — session replay, web experimentation, in-app guides and the existing event taxonomy are the daily workflow — and the behavioural questions stay within data the platform already ingests.
• Choose Mitzu when the warehouse is the system of record, behavioural questions need to join billing, CRM, support or NPS data, dbt models are already the source of truth, data egress isn't acceptable, or per-event pricing has become the wrong shape for the team's growth.
• Run both when Amplitude is the activation layer (session replay, experimentation, in-app guides) and the warehouse is the system of record for everything else — Amplitude handles the closed-loop activation surface, Mitzu answers the diagnostic and growth questions that need warehouse-native joins.

FAQ

Does Mitzu work alongside Amplitude?

Yes — they sit at different layers. Amplitude owns the activation surface (session replay, experimentation, in-app guides). Mitzu runs on the warehouse and answers behavioural questions that need warehouse-modelled context. Many teams already export Amplitude events to their warehouse via the Amplitude → S3 / BigQuery / Snowflake connectors; Mitzu can read those exported tables directly, alongside any other event sources. See 5 Alternatives to Amplitude for adjacent options if a full migration is the goal.

Does Amplitude's agent query the warehouse?

No. Amplitude's Global Agent and specialized agents operate on Amplitude's own behavioural data store — events, session replays, experiments, guides, surveys and governance metadata. Data needs to be ingested into Amplitude (via Amplitude SDKs or a CDP forwarding) before it is in scope for the agent. The agent does not author SQL against the customer's warehouse.

Does Mitzu's agent write SQL?

No. Mitzu's Analytics Agent assembles typed analysis specifications — funnel steps with a conversion window, retention cohorts and return events, segmentation filters with sampled property values, journey trees — and a deterministic query engine produces the SQL. The same specification produces the same SQL every time. The SQL is shown to the analyst as a verification artifact, not as the agent's authored work.

How does pricing compare?

Amplitude's pricing scales with MTUs and event volume, with agent capabilities tied to the platform tier. Mitzu charges per editor seat with unlimited events on every tier — the customer's warehouse compute cost is independent and controlled by the customer. See the Mitzu pricing page for current details.

Can Mitzu replace Amplitude?

For product, growth and marketing behavioural analytics — funnels, retention, segmentation, journeys, cohorts, deep dives and root-cause investigations — yes, with the prerequisite that event data is in the warehouse. For session replay, in-app guides and web experimentation, Mitzu is not the equivalent product; those surfaces are typically replaced by separate tools or kept in Amplitude during a hybrid period.

Related reading

• Warehouse Native vs First-Generation Product Analytics
• 5 Alternatives to Amplitude
• ClickHouse AI vs Mitzu
• Agentic Analytics Platforms Compared
• ChatGPT vs AI Analytics Agent
• Mitzu Semantic Layer
• Mitzu Product Analytics

References

• Amplitude — AI Agents product page
• Amplitude press — Introduces Agentic AI Analytics (Feb 2026)
• Amplitude blog — Introducing Amplitude AI Agents
• Mitzu documentation (docs.mitzu.io)