Built on a complete data model

Truth Layer + Action Layer. The data model is complete from day one — now it takes action too.

Most platforms add tables when they add features. Gurulu starts with the canonical data model, then grows both measurement AND action on the same identity graph.

Available now

Live in beta today

What you can use right now — the core four, five channels, privacy, the daily AI digest, AND the Action Layer (experiments/popups/tours/personalization/boards).

Core four, always on

The four pillars of the Truth Layer

Identity, registry, health and attribution are mandatory in every tier and every workspace. They are how Gurulu earns the word truth.

Identity engine

Live

Explainable merge with a four-tier confidence ledger. Every join, split and reassignment is recorded with the evidence that triggered it. Reversible by design.

  • Four-tier confidence: deterministic, probabilistic, AI-suggested, manual
  • Reversible merge ledger with full audit trail
  • Cross-domain resolution — open to all

Event registry

Live

Events are typed contracts. Schemas live in the registry, ingestion enforces them, so drift becomes impossible. SDKs and AI agents generate code against the registry — no freestyle event names.

  • Source-of-truth schema with validation gate at ingestion
  • Accept / Warn / Quarantine / Reject ingestion outcomes
  • Code-gen typed SDKs for every workspace

Event health

Live

Multi-selector matchers + 5-layer fail-safe + ML anomaly detection. Tracking regressions are caught before the dashboard lies — usually within minutes of deploy.

  • Multi-selector resilience for autocapture rules
  • ML anomaly detection per event / property / cohort
  • CAPI dedup so downstream destinations stay clean

Attribution engine

Live

Customer-defined policy. Pick your model, mix multiple models side by side, and see the full trace behind every credited touchpoint. No black-box numbers, ever.

  • Multi-model: last-touch, first-touch, linear, time-decay, position-based
  • Customer-defined attribution policy per workspace
  • Full provenance trace for every conversion

Five channels, five jobs

Observation, tagging, verification, contract and action — never blurred

Most platforms hide one SDK behind every feature. Gurulu separates the five jobs on purpose — every channel has a single, narrow responsibility.

01 · Script

Live

Observe

Browser autocapture only. Records raw signals — never invents outcomes, never makes up event names.

Package: @gurulu/web

02 · Playground

Live

Tag

Heap-style visual picker writes semantic rules into the registry. No events are created here — only rules that match observed signals to typed contracts.

Package: @gurulu/playground

03 · SDK

Live

Verify

Server-side outcome verification. Conversions, refunds, signups — all backend-bound so they can't be spoofed. Web identify/track is registry-bound too.

Packages: @gurulu/node + @gurulu/web

04 · Agent · CLI · MCP

Live

Contract

AI authors against the registry. Types are code-generated, freestyle event names are blocked at CI. The agent never invents a new event without a contract.

Packages: @gurulu/cli + @gurulu/mcp-server

05 · Activation

Live

Take action

Rendering popups, tours and personalization = action. It emits an exposure event but NEVER an outcome — the observation≠action separation holds. A separate opt-in lazy chunk, so the 8.1KB core stays lean.

Package: @gurulu/web/activate

Action Layer — from measurement to action

Gurulu now takes action

The Truth Layer tells you what happened; the Action Layer changes it. Experiments, popups, tours, personalization — all on the same identity graph and registry, with the same rigor.

Live

A/B/n experiments

Deterministic hash assignment (server-truth, no flicker) + Bayesian statistics (P(B>A), credible interval). Exposure is registry-bound, outcome is a verified event.

Live

Popups & banners

Rule-based modal/banner/slide-in. Server-side XSS sanitization enforced, live preview, CTR measurement.

Live

Product tours

Step-by-step onboarding tour. Cross-device progress (identity reuse), completion funnel.

Live

Personalization

Audience → content. Measure real impact with an opt-in holdout, Bayesian.

Live

Boards

Custom dashboards — a widget composition of existing insights. Not a new metric engine; K15-safe, no SDK risk.

Live

LLM analytics

Measure your own AI features: cost, latency, errors, model performance. Automatic capture via wrapOpenAI/wrapAnthropic.

Live

Error tracking

Group browser JS errors by message. Opt-in autocapture, a registry-bound js_error event.

Live

Heatmaps

Click density + scroll depth — from the autocapture signal, no extra setup.

Developer tools

It works where you write code

From the browser to the terminal to your AI editor — each tool does one job and respects the contract.

MCP server · Cursor · Claude Code · Lovable

Live

Your AI editor writes against the registry

The MCP server connects your AI assistant to your event registry. The agent lists, searches and validates a new event with validate_event before sending it — it can’t invent freestyle names. Your contract holds in the age of AI too.

  • Reads the registry: list / search / get event
  • Validates first: validate_event → add_event
  • No freestyle names — it follows the contract
Docs →
claude mcp add gurulu -- npx -y @gurulu/mcp-server

SDK · Web (@gurulu/web)

Live

Browser: autocapture + identify/track. Zero-dep, ~8 KB.

gurulu.track('signup_completed', { plan: 'pro' })
Docs →

SDK · Server (@gurulu/node)

Live

Server: trustworthy outcomes + Stripe/Shopify webhook helpers.

await gurulu.track('purchase_completed', { amount: 149 })
Docs →

Playground

Live

Heap-style point & click. Adds rules to the registry with no code.

Docs →

CLI (@gurulu/cli)

Live

init / pull / push / validate / doctor. Code-gen typed events.

gurulu pull   # typed events → code-gen
Docs →

Three event classes

Interaction, intent and outcome — split from day one

Mixing browse, signal and conversion in one table is the original sin of product analytics. Gurulu separates them in the schema, not just in queries.

Class 01

Live

Interaction

Clicks, scrolls, views — the raw stream of human behavior. High volume, low semantics.

Class 02

Coming · Phase 2

Intent

Inferred signal — a search query, a hesitation, an abandoned cart. Modeled in Phase 2+ with consent-aware enrichment.

Class 03

Live

Outcome

Backend-verified result — a purchase, a refund, a paid signup. The only class that can credit attribution.

Privacy by default

EU-native, compliance-first, multi-tenant safe

Privacy is enforced in the data model, not bolted on. Every row knows its consent state and its tenant — no leaks possible.

Live

EU residency default

Hosted in EU data centers with automatic failover. No US data transfer needed for GDPR-bound customers.

Live

4-category GCM v2

Google Consent Mode v2 wired into every event — analytics, advertising, personalization and security consent surface independently.

Live

DSR-ready exports

GDPR / CCPA / KVKK subject-access and erasure requests resolve through a single API. Audit trail included.

Live

Tenant isolation + RLS

Postgres row-level security on every table, ClickHouse partition-per-tenant. Cross-tenant queries are physically impossible.

AI layer

AI that explains itself — and never sees raw PII

Pseudonymize everything before it touches a model. Show the prompt, the citations and the confidence behind every AI suggestion.

Live

Morning summary

Phase 1 minimum: every workspace gets a daily digest of what changed, what broke and what to investigate. Cited back to the source events.

Coming · Phase 2

Intent inference

Phase 2+: classify raw behavior into intent classes (researching, comparing, ready-to-buy). Consent-aware and pseudonymized end-to-end.

Coming · Phase 3

Advanced reasoning

Phase 3+ (evolving): cross-event causal reasoning, hypothesis generation, experiment suggestion. Always paired with provenance and confidence.

Multi-model AI pipeline · region-aware automatic fallback

What’s next

On the roadmap

Clearly marked, not here yet. Every phase has a public “Done” definition.

Phased delivery

From Phase 0 to Phase 5 — the public roadmap

MVP is Phases 0–3 (~9–12 months). Phases 4 and 5 are post-MVP. Every phase has a public Done definition.

  1. 00
    Phase 0 — FoundationAuth, storage, observability, consent. 4 modules.
  2. 01
    Phase 1 — Core four + data flow + 4 channels + UIBeta opens here. 16 modules total.
  3. 02
    Phase 2 — Intent inference + integrationsIntent class lights up, CAPI destinations expand.
  4. 03
    Phase 3 — Action Layer (LIVE)Experiments (Bayesian A/B/n), popups, tours, personalization, boards + LLM analytics + error tracking. All in production. Official launch is near.
  5. 04
    Phase 4 — Cross-tenant intelligenceBehavioral benchmarks opt-in for the Pay-as-you-go tier.
  6. 05
    Phase 3+ — Native observabilityOTLP→ClickHouse customer telemetry (APM/Logs/Metrics). Spec is build-ready; code lands after closed beta.
Features — Gurulu Truth Layer