Fullcapture: Gold · Phase 0 Delivered · 2026

Fullstory event data
becomes semantic
infrastructure for AI.

Fullstory captures everything. But an agent given raw events has to re-derive meaning on every query. Gold writes meaning into the data once — so every downstream consumer, human or machine, inherits it for free.

The medallion model
Two mining methods
Property enrichment
What it looks like
All 13 events
Proof at scale
Fullstory Field Innovation Lab · 2026
2
mining methods
13
events delivered
30d
mine window
What's covered
🏅 The Medallion Model
Bronze, Silver, and the Gold layer we built
⛏️ Two Mining Methods
n-gram + NPMI sequences and episode k-means clusters
✨ Property Enrichment
Context harvested and attached at write time
🖥 What It Looks Like
Event card mockups inside Fullstory UI
📋 All 13 Events
Sequence and cluster event dictionary
📐 Proof at Scale
Pipeline architecture and next steps
The Medallion Model

Bronze, Silver — and the
Gold layer we just delivered

Exists
Bronze
Raw capture stream
The full ingested event chunk, unprocessed. Grounds session replay. Everything starts here.
Exists
Silver
Cooked & indexed events
Analytically precise. Powers Product Analytics, Story AI, MCP, and Fullcapture Warehouse. Complete, structured — but not semantic. A firehose, not a fact.
Delivered
Gold
Meaning, round-tripped in
Behavioral sequences and episode clusters written back as first-class events with enriched properties. 29,342 events on CarGo 18PNWR. 0 errors.
Silver gives you clean, structured, queryable data you can learn from. Gold is where value is realized — the outcome, not the firehose. The distinction is not technical; it is semantic.
The AI Consumer Problem

The agent is the new
first-class consumer. Raw events are the wrong unit.

FullStory's semantic layer — element names, URL groupings, event definitions — was authored for human legibility. But Story AI and MCP are now the primary interaction surface. An agent reading forty raw events to infer "this user completed checkout" is wasteful and lossy.

Silver alone
  • 40+ raw events: clicks, navs, form changes, seen elements
  • The agent re-derives "completed checkout" on every single query
  • Meaning lives in the reader's prompt, not the data
  • Context tokens consumed re-deriving what we already know
  • Different agents, different answers — no single ground truth
With Gold
  • One event: * Booking Flow Completed — on the session timeline
  • Enriched with carmake: Lamborghini, tripdays: 2 at attach time
  • Meaning is a fact in the data, computed once from warehouse data
  • Every downstream consumer — MCP, Story AI, ASR — inherits it free
  • The ground truth lives in the event, not the inference
Mining Methods

Two methods.
One semantic layer.

Method 1 — Sequence Mining

For intentional flows with a predictable ordering — login, checkout, signup. Finds n-grams (short ordered token sequences) that co-occur at statistically significant rates.

  • Tokenizes each session: click:btn → nav:/checkout → change:input
  • Scores every n-gram by support (% of sessions) and NPMI (token co-occurrence strength)
  • Collapses subsumed grams — only the most specific survives
  • Each surviving gram becomes one named Gold event
ngram + npmi 6 events mined from CarGo
Method 2 — Episode Clustering

For exploratory behaviors that don't follow a single path — car browsing, date exploration, product consideration. Groups episode windows by behavioral fingerprint.

  • →Segments sessions into episode windows anchored on a high-signal interaction
  • →Builds a feature vector per episode (event type counts)
  • →K-means clusters episodes into behavioral archetypes
  • →Each cluster becomes a named Gold event
episode + k-means 6 events mined from CarGo
The two methods are complementary: sequence mining captures intentional navigation; episode clustering captures behavioral texture. Together they cover the full behavioral surface.
Sequence Events

Ordered token sequences
fired when users complete a flow

Each session's events are tokenized into a stream. We find n-grams — short ordered sequences — that appear together at statistically improbable rates (high NPMI) in a meaningful share of sessions (support %). The sequence is the feature definition.

* Login Sequence
sequencesup 4.95%
btnclick:Login→ click:?→ change:login-email-input→ custom:User Login→ btnclick:Login
Fires when a user completes the full login handshake — button press → form entry → server confirmation → button again
* Merch Checkout Sequence
sequencesup 4.64%
click:First name→ change:given→ click:Last name→ change:family→ click:Address
Progressive form fill sequence — a reliable signal that the user is actively checking out merchandise
* Booking Flow Completed
sequencesup 1.41% npmi 2.00
custom:Checkout Success→ nav:/checkout-success→ seen:?
High-precision booking completion signal — enriched with carmake, carmodel, carname, totalprice, tripdays harvested from element properties
Episode Cluster Events

Behavioral archetypes
discovered by k-means

For behaviors that don't follow a single path, we slice sessions into episode windows — bounded bursts of activity around a high-signal anchor event (e.g. viewing a car detail page). Each window becomes a feature vector; k-means groups them into archetypes.

* Deep Car Consideration
cluster 10 · split: btnclick_Book_Now = 0 · sup 67.2%
Extended browsing on car detail pages without booking — date exploration, image scrolling, feature review. High feature-count episode; the user is evaluating, not converting.
* Car Detail Direct Booking
cluster 10 · split: btnclick_Book_Now = 1 · sup 18.7%
Same cluster, Book Now click present — decision made on the detail page. One cluster, two events, split by a single boolean feature.
* Date Availability Explored
cluster 9 · sup 7.7%
High date picker interaction rate. User is checking availability windows — intent signal without a booking commitment.
Clusters are not hand-authored. k-means found these archetypes from behavioral data. We named them after reading per-cluster feature differentiators.
* Login Mid-Flow Booking event panel in FullStory
* Login Mid-Flow Booking — live in FullStory. Cluster event with gold_str, duration_ms, started_at properties.
Under the Hood

Models, techniques,
and hardcoded guardrails

Sequence miner — ngram + NPMI
Tokenizer — each session event collapses to type:element (e.g. click:car-result, custom:User Login). Special characters stripped; case-collision pairs suffixed.
n-gram enumeration — every contiguous ordered sub-sequence of length 2–7 is counted across the full session corpus.
NPMI scoring — Normalized Pointwise Mutual Information measures how much more likely a token sequence is to appear together than by chance. Score = PMI / −log P(gram). Eliminates high-frequency noise (e.g. click → nav appears everywhere but means nothing).
Closed-gram collapse — a gram is dropped if a longer gram that subsumes it (contiguous prefix/suffix) covers ≥ 85% of the same sessions. Keeps the most specific, non-redundant description.
Episode miner — k-means on behavioral windows
Anchor event — sessions are windowed around a single high-signal interaction (e.g. click:car-result). The anchor is chosen for its causal relationship to the behavior of interest — not just frequency.
Feature vector — within each episode window, event-type counts are tabulated into a fixed-width numeric vector (36 features for CarGo car-detail). Normalized before clustering.
k-means (k=12) — clusters episodes into behavioral archetypes. k is chosen by elbow method on inertia. Clusters are reviewed manually: top-differentiating features per cluster surface the semantic interpretation.
Cluster splitting — a cluster can be split into two named events by a single boolean predicate on any feature (e.g. btnclick_Book_Now = 1 vs = 0), producing finer-grained semantic labels without re-running k-means.
Support floor
Sequences below the minimum support threshold are rejected before NPMI scoring. Prevents low-volume noise from becoming Gold events.
First-occurrence only
QUALIFY ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY started_at) = 1 — one Gold event per session per feature, always. No double-counting.
Idempotency
SHA256(RUN_ID|offset|size) per batch chunk. Re-running the same RUN_ID is a no-op. Changing RUN_ID produces a fresh run without duplicates.
Dry-run gate
DRY_RUN=True runs all queries and prints sample events — never calls the API. The pipeline cannot fire without explicitly setting it to False.
Property Enrichment

Events are enriched with
context harvested at attach time

A Gold event isn't just a timestamp on a session. It carries properties harvested from element data across the session — the latest non-null value for each field, coalesced across all member events. A booking event knows what car was booked.

⚡
* Booking Flow Completed
August 22 at 7:58 PM
carmake_strLamborghini
carmodel_strDiablo
carname_strLamborghini Diablo 2016
duration_ms_real5090
kind_strsequence
gold_strFCG1;area=booking_flow_completed;len=3;sup=1.41;npmi=2.00;algo=ngram+npmi;kind=sequence;run=fcg-20260824c
⚡
* Date Availability Explored
August 21 at 8:49 AM
duration_ms_real63,464
kind_strcluster
started_at_date2026-08-21T12:48:12Z
gold_strFCG1;area=date_availability_explored;len=7;sup=0.0767;npmi=NA;algo=episode+kmeans;kind=cluster;run=fcg-20260824c
* Booking Flow Completed schema in FullStory Lexicon
Harvest logic: We coalesce the latest non-null value for each property across all session events. Sessions browse multiple items — any single event is often incomplete. Last-seen wins.
Zero engineering by the customer. Harvest queries run against Fullcapture's element_properties table. No SDK change, no custom event, no tag — the data was already there.
The Gold String

Machine-readable metadata
encoded in every event

Every Gold event carries a gold property — a single string that encodes full provenance. An AI agent can parse the origin, method, confidence, and run ID from one field without joining any other table.

FCG1;area=booking_flow_completed;len=3;sup=1.41;npmi=2.00;algo=ngram+npmi;kind=sequence;run=fcg-20260824c
area
Machine slug
Stable, SQL-safe identifier for the feature area. Never changes, even if the event name is updated.
sup / npmi
Confidence signal
Support = % of sessions. NPMI = token co-occurrence strength (NA for cluster events). Tells AI how reliable the event is.
algo + kind
Method provenance
ngram+npmi / sequence or episode+kmeans / cluster. The AI knows how to weight each type differently.
run
Pipeline run ID
Idempotent — every event from a given run carries the same ID. Supports deduplication, rollback, and time-travel analysis.
The * prefix on event names (asterisk + space) is not decorative. * sorts before all alphanumeric characters, so Gold events float to the top of every alphabetical list in FullStory — no custom grouping, no configuration required.
In Fullstory

Gold events appear on
existing session timelines

No new UI. No new tab. Gold events are first-class server events — they appear directly in session replay alongside every other event. William Anderson booked a Lamborghini Diablo. The event arrived in the timeline within seconds of the batch completing.

FullStory session replay showing * Booking Flow Completed Gold event for Madison Flores booking a Jeep Wrangler JK
Madison Flores · Jeep Wrangler JK 2019 · Gold event visible in the right-panel event timeline
⚡
* Booking Flow Completed
August 22 at 7:03 PM
carmake_strJeep
carmodel_strWrangler JK
carname_strJeep Wrangler JK 2019
duration_ms_real5,059
gold_strFCG1;area=booking_flow_completed;len=3;sup=1.41;npmi=2.00;algo=ngram+npmi;run=fcg-20260824c
Events appear in session replay within seconds of the batch completing. No cache invalidation — the server events API writes directly onto the session timeline.
Fullstory Expertise, Encoded

A decade of behavioral intelligence
written into your data

Fullstory has spent over a decade understanding how behavior clusters and sequences should be reasoned about in the context of Product Analytics and Digital Experience. Gold encodes that expertise directly into your event data — so analysts, Story AI, and MCP agents all start from meaning, not from raw events they have to mentally mine themselves.

🎬
Agentic Session Review
ASR reads session timelines. Gold events are the semantic anchors it should use to structure its analysis. A session with * Booking Flow Completed on the timeline is categorically different from one without it — ASR knows this immediately, without re-deriving it.
✨
Story AI
Story AI queries events by name. Gold events float to the top of every list. The gold string gives it confidence context — sup=4.95% tells Story AI how prevalent the behavior is across the org, not just in this session.
🔌
Analytics MCP
MCP tools like get_sessions and build_funnel work on event names. Gold events are queryable by name and by property — "find all sessions where * Login Mid-Flow Booking fired" is a single MCP call.
The area slug is the stable key. booking_flow_completed will never change even if the display name is refined. Analyst dashboards, MCP queries, warehouse joins, and AI tool calls can all key off it durably.
The gold string is self-describing. Any consumer — human or agent — can determine whether an event is sequence-mined or cluster-derived, how confident the label is, and which pipeline run produced it — from a single property, with no external lookup.
The Event Library

11 Gold events delivered
across 12 behavioral domains

FullStory event type list showing all 11 Gold events sorted alphabetically
FullStory event type list — * prefix sorts Gold events to the top
EventMethodSessions (30d)
* Login Sequence
seq8,116
* Merch Checkout Sequence
seq6,359
* Car Search Sequence
seq6,197
* Deep Car Consideration
clu2,997
* Booking Flow Completed
+ carmake, carmodel, carname, totalprice
seq2,276
* Host Signup Sequence
seq2,024
* Car Detail Direct Booking
clu863
* Date Availability Explored
clu351
* App Direct to Cart
clu74
* Signed Up to Save Car
clu55
* Login Mid-Flow Booking
clu30
The Pipeline

Mine. Match. Enrich.
Round-trip. On schedule.

The full pipeline runs top-to-bottom from one parameterized notebook. No bespoke engineering per customer — the method is identical across orgs. Only the feature seeds change.

Stage 1–2
Silver Warehouse
Fullcapture tables — clicks, navs, form changes, custom events
›
Stage 3–4
Tokenize + Mine
n-gram scoring with NPMI; episode windowing with k-means
›
Stage 5
Collapse + Label
Drop subsumed grams; assign semantic names; define clusters
›
Stage 6–8
Match + Harvest
Find sessions where events fired; coalesce element properties
›
Stage 9
Push Gold
Batch import via FS v2 Events API; idempotent by run ID
→
session.id = warehouse session_id
The Fullcapture warehouse session_id column (deviceId:sessionId) maps directly to the FS Events API session.id field. No translation, no join — the warehouse format is the API format.
→
Idempotent by run ID
Every batch chunk carries a SHA256 idempotency key derived from RUN_ID + chunk_offset + chunk_size. Re-running with the same RUN_ID is a no-op. A new RUN_ID produces a new run without duplicate events.
→
50,000 events per batch, async polling
The v2 batch endpoint is async. We submit and poll GET /v2/events/batch/{job_id} until status exits PROCESSING. The 30-day CarGo run completed in ~8 minutes.
Proof at Scale

29,342 events. 11 features.
30 days. 0 errors.

29,342
Gold events imported — 30-day window, CarGo org 18PNWR
0
API errors across 1 batch job — COMPLETED status
~8 min
Wall-clock for the full batch to complete (submit → COMPLETED)
~$0.10
Estimated BigQuery compute per full mining pass
* Login Sequence 8,116
* Merch Checkout Sequence 6,359
* Car Search Sequence 6,197
* Deep Car Consideration 2,997
* Booking Flow Completed 2,276
* Host Signup Sequence 2,024
Confirmed working end-to-end: session.id resolution (anonymous + identified), batch async polling, property enrichment via element_properties harvest, and visual confirmation in session replay. Phase 0 is not a demo — it's a running pipeline.
The Vision

A customer buys Gold.
The next day, events appear.

No engineer involvement. No professional services engagement. The customer selects their primary feature surfaces — we examine their Fullcapture data, mine their sequences, and Gold events appear inside their org. A product motion, not a services motion.

Proven
Method works on CarGo 18PNWR. Two mining algorithms. 29k events. 0 errors. Session replay confirmed.
Portable
The notebook is parameterized. Only feature seeds change per org. The pipeline and code are identical across customers.
Next
Co-creation with 2–3 Warehouse-connected customers. Automate feature seed discovery. Schedule via Vertex AI Pipelines.

Fullcapture: Gold · Phase 0 Delivered · Field Innovation Lab · 2026

1 / 15