Changelog
New features, improvements, and fixes — most recent first.
0.16.0— Audiences Out of the Box
July 2026
Audience profiles used to require manual setup that almost nobody did — so for most projects they stayed empty. No more. The SDK now understands your pages and how visitors engage with them by default, with zero tagging and zero configuration. Install it, and your audiences fill themselves in.
The React SDK and the no-code snippet now detect what each page section is (pricing, hero, social proof, …) and measure how long visitors actually look at it — on by default, no tagging needed. That's the raw material for audience profiles, so Buyers, Researchers, and friends now appear for a standard install instead of requiring manual instrumentation. Explicit data-sentient-type tags still win when you want precision, and everything can be switched off (enableGraph={false}, engagement={false}, or sectionCapture: false). Do-Not-Track, Global Privacy Control, and your consent gate always take precedence.
Expanding a component on the Experiences page now shows behavioral signals per option: frustration clicks, quick exits, long hovers, reading pauses, and text copies. These signals never change your scores — they're there to tell you why an option might be winning or losing.
The Home page now charts your audience mix over time — how many visitors from each audience were active per day or week — replacing the old single-moment snapshot. Audience growth in Trends also reads chronologically now (prior period first) with a change indicator per audience.
Audiences no longer show up twice under singular and plural names — legacy labels are merged onto one canonical audience each. Goals fired straight from code now read in plain language everywhere and can be promoted to primary from the dashboard. The DOM Graph moved under Advanced with a clearer explanation of what its relationships mean.
0.15.0— Numbers You Can Trust
July 2026
A measurement-integrity release. Every project now measures its conversion lift against a built-in control group by default, every dashboard number counts human visitors only, and every surface says exactly what it is measuring. If SentientUI is making you money, the lift card proves it — and if it isn't yet, it says that too.
New projects hold out 10% of visitors as a control group that sees your unmodified site — across every surface: styles, content variants, and section order. The lift card compares converted control visitors against personalized ones with a proper significance test, and is honest when there isn't enough data to call it. Adjustable or disabled per project in Settings.
Automation traffic — E2E test drivers, agentic browsers, bots — is now excluded from every conversion rate, trend, insight, and suggested winner, matching what the optimizer learns from. Agent and crawler activity still shows up, in its own traffic breakdown where it belongs.
Forcing a variant with ?sentient_variant= or the devtools override now records no exposures, goals, or signals — so browsing your own site in a forced state can never teach the optimizer the wrong thing.
client.identify(userId) now carries the visitor's best profile onto the current device the moment the identity is linked — returning users get their personalized experience on a new device without re-learning from scratch.
The Activity page can now export the filtered audit trail as CSV. Audit history and webhooks both respect per-project member access: admins see everything, editors and viewers see the projects they've been granted.
DELETE /v1/visitor now removes every visitor-keyed record in a single atomic operation. Previously the erasure could fail for visitors who had converted; it now completes for everyone, every time.
0.14.0— The Adaptive Ladder
July 2026
Four rungs, one concept: declare a bounded set of variations — styling, content, or section order — and the optimizer learns which one converts best for each visitor type. Start with CSS-only adaptation and climb one rung at a time. Try everything with no account: one command runs the whole SDK in keyless local mode on your machine.
The SDK sets data-sentient-persona and data-sentient-confidence on <html> before first paint — style visitor types with plain CSS. useAdaptiveTokens declares a bounded token set (e.g. tone: calm/urgent) and serves the best-converting look per visitor type as data-* attributes, server-rendered with zero flicker.
Headless variant selection with measurement built in — a required goal and a bind you attach to the rendered element wire exposure tracking and goal listeners automatically. Supersedes useAssignment (which stays for backward compatibility).
Reorder a region into designer-approved arrangements of keyed children — never free shuffling, locked per visit, and any mismatch falls back to your declared order.
Run the entire SDK with no account and no API key: development builds simulate decisions deterministically on your machine with zero network. One command detects your framework, wires the provider, and scaffolds an example — then open your app with ?sentient_persona=buyer to watch it adapt. Production bundles physically exclude the local engine.
One script tag brings the Style rung to any website: persona attributes plus learned style tokens, applied as data-* attributes so your CSS does the visual work. It never reorders the page, and any error or timeout leaves the page exactly as it was.
Learning now counts one result per completed visit per component, closed out after 30 minutes of inactivity — fixing a bug where extra goal events inflated some variants’ results. Dashboard copy now says "times shown" everywhere, and per-visitor-type learning powers every new surface.
New overview cards show what each visitor type sees and the conversion rate of every look, plus a "Suggested next step" card with ready-to-paste snippets. The conversion lift card now breaks out layout changes vs. style & content changes against your control group.
0.12.0— Testing Toolkit
July 2026
Make adaptive UI deterministic in your own tests. @sentientui/react/testing forces variants and layouts, mocks the API, and asserts goals across Jest, Vitest, React Testing Library, Playwright, and Cypress — so a test that looks for specific copy never breaks when the optimizer serves a different variant, and CI never sends fake traffic into your project.
Render any SentientUI component with the control variant and default layout by default (no network), or pass a scenario to force specific variants/layout. Existing tests keep passing with zero per-test setup.
setupSentientServer() is an MSW-backed mock backend for every endpoint, with API error injection and event capture — assert that a goal fired with hasFiredGoal(getSentientEvents(), …).
mockSentient(page, scenario) and mockSentientCypress(cy, scenario) force variants/layout, stub the API, and capture events in E2E. The ?sentient_variant= URL param still works for a zero-import pin.
AdaptiveRoot and preloadDecisions/preloadAssignments now default timeoutMs to 1000 ms (was 1500 ms). A decide served from the API in-process cache typically returns in well under 150 ms; the full budget is only reached on a cold start or an API geographically distant from your SSR host, after which default variants render with no layout shift. Override timeoutMs if your API is co-located and warm.
0.11.0— Adaptive DevTools
July 2026
A dev-mode floating widget for @sentientui/react that confirms your integration is wired up and lets you preview it with zero data written. See every <Adaptive> component on the page with its variants and goals, force any variant live, and preview any persona's layout — then ship nothing to production, because the widget is a separate, tree-shaken subpath.
Import AdaptiveDevtools from @sentientui/react/devtools and render it inside your provider during development. It lists your components, variants, and goals, forces a variant live via an override, and previews any persona through the new /v1/explain endpoint. Guarded by NODE_ENV so production bundles ship none of the devtools UI.
Entering preview mode swaps in an event-suppressing client, so forcing a variant or persona never sends a variant_assigned, goal, or session event — you explore safely against your real page.
0.10.0— Do Not Track
July 2026
SentientUI now honors the browser's Do Not Track signal by default. When a visitor has DNT enabled, the SDK sets no cookies and sends no tracking data — a privacy-first default you can override with your own consent gate.
New respectDoNotTrack option on init() and <AdaptiveProvider> (default true). With DNT enabled the SDK stores nothing and sends nothing, overriding consent: true and preventing grantConsent() from re-enabling tracking. Set it false to make your own consent gate authoritative. Also exports isDoNotTrackEnabled() from core.
0.9.0— On-Demand Component Graph
July 2026
The component dependency graph — DOM scanning and reward propagation across related components — is now opt-in per app. A new enableGraph prop on <AdaptiveProvider> and <AdaptiveRoot> lazy-loads @sentientui/core/graph only when you ask for it, so apps that don't need graph-aware rewards keep the smaller bundle. Turning it on powers the dashboard Graph page with live structural and semantic relationships between your components.
Set enableGraph on <AdaptiveProvider> (or <AdaptiveRoot>) to load @sentientui/core/graph on demand and initialise the client with graph scanning + sync enabled. This is what feeds the dashboard Graph page — component relationships and cross-component reward propagation. It is off by default, so lean consumers keep their bundle size unchanged.
0.8.0— Custom API Domain
June 2026
The SDK now defaults to api.sentient-ui.com — SentientUI's own domain with global edge routing. Latency is lower for visitors worldwide, and the integration is no longer coupled to any underlying infrastructure hostname. Existing integrations keep working without any changes.
@sentientui/core and @sentientui/react now point at https://api.sentient-ui.com out of the box. No action required — new and existing installs work without changes. If you proxy the API through your own domain, continue using the ingestUrl or baseUrl overrides in init() / AdaptiveRoot as before.
Phase 5 · SDK 0.6.0— Inferred Goals + Faster Funnels
June 2026
SentientUI now learns from partial funnel completion and discovers meaningful goals on its own. Weighted composite goals let the optimizer converge 3–5× faster on long funnels by crediting each step independently as it fires. Micro-signal detection passively tracks rage clicks, text selection, scroll hesitation, and early tab abandonment — no developer configuration. After 500 sessions in observation mode, SentientUI automatically groups these signals and suggests which ones to promote to real goals.
A new WeightedCompositeGoal type on <Adaptive> gives each funnel step its own fractional score. A visitor who viewed pricing (weight 0.2) but bounced before signing up still generates signal. Steps fire independently — the optimizer does not wait for all steps to complete. Existing CompositeGoal behavior (all-or-nothing, full score) is unchanged.
Every <Adaptive> component now passively observes four behavioral signals: rage clicks (3+ within 500 ms), text selection / copy, scroll hesitation (3 s of no scroll while visible), and early tab loss (hidden within 15 s). Signals are sent through the existing event pipeline as micro_signal events. No developer configuration required — detection attaches automatically on mount.
Fixed a cache-key mismatch that caused unnecessary /assign calls when sessionSegment was not set, coalesced concurrent assigns for the same component into one request, and capped previewHtml uploads to once per variant per session. Bundles are now minified (react: ~3.7 KB gzip). Breaking for direct core users: preloadAssignments, preloadDecisions, and readSessionCookie moved from '@sentientui/core' to '@sentientui/core/server'. Imports from '@sentientui/react/server' are unaffected.
New observation mode for projects. While active, the optimizer computes portraits and audience groups but withholds variant weight updates — every session contributes data without committing to a winner. Once 500 sessions accumulate, SentientUI groups micro-signals by component, labels the top behavioral patterns with AI, and surfaces them in the dashboard as "Moments we noticed". Developers confirm or dismiss each suggestion; confirming shows a ready-to-copy SDK snippet.
Phase 4— AI Intelligence Layer
June 2026
SentientUI adds its first AI layer. Every project page now opens with AI-generated observations about what changed this week — narrator bullets for all paid plans, action recommendations for Growth. Persona audience-group names are generated dynamically from behavioral patterns. Guardrail alert emails include an AI-written diagnosis of why a variant dropped. Agent endpoint usage is now fully observable.
Every project overview now shows an InsightsFeed: 3–5 plain-English observations about what changed this week (variant CVR shifts, persona velocity, session volume, guardrail events). Growth tier projects also get 1–2 specific recommended actions. Insights are generated on-demand and cached for 6 hours. The Refresh button triggers a new generation; results appear in under 30 seconds.
Persona audience groups are no longer hardcoded as "buyers", "researchers", "deal-seekers", "browsers". On each insights refresh, AI reads the behavioral profile of each audience group and generates a human-readable label — "Cautious Evaluators", "Fast Converters", and so on. Dynamic labels appear on the Visitors page alongside the raw portrait dimensions.
When a variant is auto-paused by the guardrail (CVR dropped below threshold), the alert email now includes a 1–2 sentence AI-written diagnosis of the most likely cause. If the diagnosis is unavailable, the email sends without it rather than being delayed.
GET /v1/agent/layout calls are now fully tracked — project, visitor, resolved persona, and blocks served are all recorded. The project health endpoint exposes an agent call count. Previously, agent calls were fire-and-forget with no usage visibility.
The dashboard now computes week-over-week CVR deltas, momentum scores (gaining / stable / losing), persona velocity, portrait drift, session volume trends, and per-device / per-source CVR breakdowns. A TrendsCard on the project overview surfaces the top signals. A dedicated Trends tab shows the full breakdown.
Phase 3— Layout Intelligence & Cross-Session Identity
May 2026
SentientUI expands from component-level A/B testing to full-page layout optimisation. A single server roundtrip now decides both section order and variant assignments. Cross-session identity links anonymous visitors to authenticated users so optimizer learning carries over across sign-in. Text content variants ship as a first-class primitive.
Pass a sections array to <AdaptiveRoot> and SentientUI will reorder your page sections for each visitor in a single server roundtrip — no extra network call, no layout shift. Section order is determined by persona: visitors whose audience group matches a section's historical engagement pattern see that section promoted to the top. The resolved order is seeded into React context so client components stay in sync.
A new <AdaptiveText> component lets you run copy experiments without wrapping entire subtrees. Provide a default string and an experiment ID; the SDK fetches the winning content variant from the API and swaps it in after mount. Impressions are tracked automatically.
Call client.identify(userId) after sign-in to link the anonymous session to an authenticated user. Optimizer weights, portrait scores, and persona assignments carry over — returning users see the variant that worked for them last time, not a fresh exploration draw. Pass userId at init time if the identity is already known on page load.
client.goal(name, metadata?) lets any client-side code fire a named conversion event — form submissions, checkout steps, video plays — without wiring up a full event schema. Goals are correlated with the active variant assignments server-side and feed directly into the optimizer as conversion signal.
preloadDecisions() replaces preloadAssignments() for pages that use layout reordering. One POST /v1/decide call resolves section order and all variant assignments together, reducing server-side latency before the first byte is sent to the browser.
Goal events now train a per-persona optimizer on which section orders convert best. The winning layout per persona improves automatically over time as more sessions accumulate. Layout order is also locked per session, so returning visitors within the same session always see a consistent page structure.
The per-component optimizer replaced its launch-era fixed exploration schedule with a smarter exploration strategy driven by statistical uncertainty about each variant's conversion rate — variants with less data are explored more, confident winners are served more often — so convergence is faster with nothing to tune.
Phase 2— Intelligent Experimentation
May 2026
SentientUI graduates from a single-component optimizer to a full adaptive experimentation platform. Portraits, persona audience groups, and graph-aware score sharing between related components ship in production.
The SDK now builds a six-dimensional behavioural profile for every session as events arrive: urgency, attention span, decision stage, price consciousness, risk aversion, and social influence. Each dimension is a 0–1 score computed from dwell time, scroll depth, and event patterns. Portraits update continuously as events arrive; a reliability score (0–1, based on data volume) indicates how much weight to place on each profile.
A nightly job groups sessions into four behavioural personas — buyers (high urgency, ready to convert), researchers (thorough, high attention, late decision stage), deal-seekers (price-conscious, heavy comparison), and browsers (exploratory, low urgency). Once a session accumulates enough events for a reliable portrait (reliability ≥ 0.3), the optimizer switches from generic device+source segments to persona-specific weights. Each persona can now have a different winning variant.
The SDK optionally scans the DOM to discover structural and semantic relationships between components — hero → CTA → pricing, for example. These relationships are used to share conversion credit up to two hops: when a goal fires on one component, variants on related components receive a weighted fraction of that score. This means a headline variant gets partial credit for a pricing conversion it influenced, and the optimizer learns faster on low-traffic components by borrowing signal from high-traffic neighbours.
Assignment now resolves the richest available segment for each session: device + source when a session is new, expanding to device + source + persona group once audience grouping has run. Each segment has its own independent optimizer weights, so buyers and researchers can be served entirely different winning variants from the same experiment.
Exploration rate now decays independently per variant as traffic accumulates. High-traffic variants converge to exploitation faster, while low-traffic variants stay exploratory longer so no variant is starved of signal early in an experiment.
Variant cards now show the breakdown between direct score (events on the component itself) and shared score (credit flowing in from graph neighbours). This makes it clear why a variant won even when its direct conversion rate looks low.
Full billing integration ships: upgrade flows, self-serve plan changes, and session-limit enforcement at the API layer. At launch the Free tier (10k sessions/month) and paid tiers (Starter 100k, Growth 1M) were enforced in production; these limits have since been revised — see the pricing page for current plans.
The event-ingest and assign endpoints are now rate-limited per project. The current best-variant snapshot per segment is cached server-side, so assignment latency stays low at scale without sacrificing freshness.
Phase 1— Open Beta
April 2026
Initial launch. Core self-learning variant optimizer, <Adaptive> React component, SSR preloading, live dashboard, and the Free plan.
Per-component optimizer with segment-aware weights. Exploration decays as data accumulates; exploitation shifts traffic to the highest-CVR variant automatically.
Wrap any element in <Adaptive>. Variant assignments are fetched server-side by <AdaptiveRoot> and injected into the initial HTML — zero layout shift, no loading flash, crawlable markup.
Live variant stats via SSE: CVR, Wilson 95% confidence intervals, lift vs control, and segment breakdown by device and traffic source. One-click promote locks the winner.
Pass consent={false} to AdaptiveRoot or AdaptiveProvider to gate all SDK behaviour behind explicit visitor consent. The SDK does nothing until consent is granted.