Pulse — Autonomous Marketing-Ops Agent

Cookieless analytics with an autonomous agent: it watches real-time ClickHouse data, catches wasted ad spend, verifies it with auditable rules, and emails the fix — no dashboards to read.

Comment

Inspiration

Every e-commerce store drowns in analytics dashboards that nobody reads. The data is there — wasted ad spend, a campaign bleeding money, a high-intent visitor who didn't convert — but a human has to notice it, interpret it, research a fix, and act. Most never do.

We kept asking: why is analytics still a thing you read, instead of something that acts for you? Tools like GA4 and DataFast show you charts. We wanted an agent that watches your store on its own and does something about it — the way a great growth marketer would, but 24/7 and without being asked.

That's Pulse: cookieless commerce analytics with an autonomous agent at its core.

What it does

Pulse is two things in one product:

1. A real-time, cookieless analytics platform. One script on your store streams the full GA4 e-commerce funnel (page_view → view_item → add_to_cart → begin_checkout → purchase) plus orders into ClickHouse in real time. You get a GA4-grade dashboard: live "Realtime" view with active visitors and per-visitor journeys, geo, device/browser, top products, traffic sources, and a Conversion Likelihood (CCP) model that predicts the $ value of an incoming visitor by segment.

2. An autonomous marketing-ops agent that acts. A daemon — not a button — watches the data every tick and, with zero manual intervention:

  • pulls real-time revenue and campaign ROAS from ClickHouse,
  • compares it to conversion-likelihood benchmarks,
  • validates the finding against an auditable Prometheux rule (a decision with lineage, not a black-box LLM guess),
  • researches live market context with Tavily,
  • and acts — it emails the recommendation and logs it, no clicks required.

In our demo store MONO (a furniture shop), the agent autonomously caught this and emailed it:

Meta Ads critical ROAS performance drop — Meta Ads is underperforming with a ROAS of 0.84 on $4,480 spend, far below the 1.5 threshold, driven by a 4.3% conversion likelihood. Shift budget to google_search (ROAS 15.2) and newsletter (116.5).

No human opened a dashboard. The agent found it, verified it, and sent the fix.

How we built it

The stack is the story — every sponsor tool does real work at runtime:

  • ClickHouse (Cloud) — the real-time data store the agent reads every tick. Multi-tenant via client_id as the leading sort key, read-time aggregation (funnels, conversion likelihood, consent rate), ~1s freshness. This is what makes a real-time autonomous agent possible.
  • Prometheux — executable, auditable business logic. We bind a Vadalog rule directly to our ClickHouse orders table; the agent calls it to confirm "wasteful campaign" with lineage, so every action traces to a rule, not an LLM hunch. Each verified action shows a ✓ Prometheux badge.
  • Tavily — the agent's live web-research tool, grounding recommendations in real market/competitor/season context.
  • Gemini (Google DeepMind) — the agent brain: a tool-calling loop that autonomously decides which tool to use and when, then writes the recommendation.
  • Cursor — our entire build was done in Cursor.

Around them: a lightweight Hono + TypeScript collector that serves the cookieless tracking script and ingests events/orders; a Next.js (App Router) + Tailwind dashboard, docs, and the live storefront; Nodemailer for the agent's email action; and a worker daemon that runs the Gemini function-calling loop with six tools (query_metrics, conversion_likelihood, predict_conversions, audit_rules, web_research, publish_action) and a dedupe layer so it only acts on new anomalies.

Architecture in one line: tracking script → collector → ClickHouse → autonomous agent (Gemini + Tavily + Prometheux) → real action (email) + dashboard, all in real time.

Challenges we ran into

  • Real-time vs batch. ClickHouse is built for analytics, not 1-row-at-a-time inserts. We used a synchronous micro-batch path to get ~1s end-to-end latency so the agent reacts to live state.
  • Auditable reasoning over ClickHouse. Getting Prometheux's Vadalog to read our ClickHouse table was the hardest bit — raw @bind doesn't carry credentials, so we had to bind via a JDBC URL with auth inline. Once it clicked, the agent's decisions became provable.
  • Stopping the agent from spamming. A naive loop re-publishes the same finding every tick. We added stable dedupe keys + an "already-open issues" feed so it acts on a problem once, like a human would.
  • Honest, cookieless attribution. Consent loss creates blind spots, so we label revenue as observed and source as estimated, and the agent reasons with that uncertainty instead of pretending.
  • A long tail of real-product details: timezone-correct local timestamps, per-visitor cookieless identities, live polling without flicker, and a from-scratch rebuild around the demo store.

What we learned

  • ClickHouse is an ideal substrate for agents — real-time, queryable state an agent can poll every few seconds at scale.
  • Auditability makes LLM agents trustworthy. Putting the business rules in Prometheux (with lineage) turns "the AI said so" into "this rule fired on this data" — the difference between a demo and something a merchant would actually let act.
  • Autonomy + action beats another dashboard. The moment the agent emailed a fix no one asked for, the whole project clicked.

What's next

  • Ad-platform connectors (Meta/Google Ads API) to pull real spend and let the agent transact — pause campaigns, shift budget.
  • Cross-tenant network benchmark — a privacy-safe data moat where every new store instantly benefits from pooled conversion signals.
  • More action channels (Slack, webhooks) and a per-visitor propensity model for true 1:1 retargeting.

Built With

ClickHouse · Tavily · Prometheux · Gemini (Google DeepMind) · Cursor · Next.js · TypeScript · Hono · Nodemailer · Tailwind CSS

Built With

Share this project:

Updates