SentientUI
v0.8·Dynamic interfaces for React, now public beta

The interface that adapts itselffor every visitor.

SentientUI is a hosted learning layer for React. Your sign-up, pricing, and onboarding pages build a portrait of every visitor in real time — then serve the variant, copy, and section order most relevant to who they appear to be. SSR-safe. Zero layout shift. One npm install.

Free for 10,000 sessions / mo·GDPR-friendly, no fingerprinting·SSR-safe, no layout flash

Drops into the stack you already ship

Next.js App RouterReact 18 + 19Vite · Remix · CRATypeScriptVercel · Cloudflare · NetlifyTailwind-friendlyServer componentsNext.js App RouterReact 18 + 19Vite · Remix · CRATypeScriptVercel · Cloudflare · NetlifyTailwind-friendlyServer components
6
portrait dimensions
updated as events are processed
4
auto-clustered personas
buyers · researchers · deal-seekers · browsers
2-hop
score sharing
graph-aware credit, low-traffic learns faster
<1.5s
SSR preload timeout
graceful fallback to defaults

The same page, arranged differently.

Resolved server-side before the first byte — no layout shift, no flash. First visits are ordered by device and traffic source; returning visits by learned persona.

yoursite.com
Buyer
Hero banner↑ top
Start free trial — no card needed
Social proof
Pricing table
Docs & API ref

High urgency · paid traffic · 1st visit

Not another A/B tool — a learning layer.

You already have feature flags and A/B platforms. Here's why teams move conversion-critical surfaces to SentientUI.

LaunchDarkly / Statsig

Feature flags — you ship variants, you decide the winner

Requires analyst time to read results and manual rollout decisions
Optimizely / VWO

Classic A/B — wait for significance, then act

Wastes traffic on the loser for the entire experiment window
Mutiny / Intellimize

Marketer-led personalization rules

Not React-native; rules-based personalization without component-level AI optimization
you are here
SentientUI

Dynamic software interfaces — your pages learn who each visitor is and adapt in real time, automatically

Hosted API, zero ops — the dynamic interface layer ships with one npm install

Four things a static page can't do.

Adaptive interfaces aren't personalization rules. They're a real-time learning loop that ships in your existing React tree.

Zero layout shift

Your visitors see the right dynamic interface instantly — no flicker, no loading flash. Decisions are preloaded server-side and land in the first HTML.

Adapts to every intent

Every visitor gets a dynamic interface matched to who they are — buyers see urgency, researchers see depth, deal-seekers see offers — when you declare variants for each. Not one-size-fits-all.

Gets smarter with every conversion

Live conversion rates, accuracy ranges, and what's improving — all in the dashboard. Your dynamic interfaces train themselves; you watch the lift.

AI tells you what changed

Every project opens with plain-English observations about what shifted this week — conversion rate momentum, audience velocity, profile shifts. Growth plans get specific recommendations on what to do next.

Built for teams serious about conversion.

For SaaS teams who know static pages leave conversion on the table — and want to fix it without hiring a data team.

PLG SaaS

Your sign-up and onboarding pages see buyers, researchers, and deal-seekers every day — and show them all the same thing. Dynamic interfaces fix that. SentientUI learns from your conversions automatically, no experiment program to staff.

Landing page teams

Thin traffic can't wait for A/B significance windows. Dynamic interfaces shift toward what converts continuously — building signal from every session, not just the ones that reach significance.

Next.js App Router teams

Dynamic interfaces arrive server-side, before the page paints. No layout shift, no loading flash — the right version for each visitor on every request. You never deploy the learning stack yourself.

Solo founders

Open SDK on npm, hosted intelligence out of the box. Declare your variants in JSX and your dynamic interface starts learning from day one — no infrastructure, no data team.

Frequently asked.

Everything you need to know before you integrate.

No. SentientUI runs the learning API, optimizer, visitor profiles, audience grouping, and graph storage on our infrastructure (api.sentient-ui.com). You install @sentientui/react, add API keys from the dashboard, and point env vars at our hosted endpoints. There is no customer-facing self-host path today — you focus on your React app; we operate the learning loop.

Feature flags and classic A/B tools expect you to configure experiments, read dashboards, and ship winners manually. SentientUI is a dynamic software interface layer: your sign-up, pricing, and onboarding pages learn who each visitor is and adapt automatically — no experiment manager, no analyst making the call. The AI optimizer, visitor profiles, and audience groups run on our hosted API; you just declare your variants in JSX.

SentientUI runs an AI optimizer per component, per audience segment. It maintains a probability distribution over each variant's conversion rate and samples from it to decide which to show. Uncertain variants (less data) are naturally explored more; confident winners are served more often. The algorithm self-tunes without a fixed exploration schedule — you never need to declare a winner manually, though you can promote one at any time.

A portrait is a real-time behavioural profile built for every session. It tracks six dimensions — urgency (how quickly the visitor moves toward conversion), attention span (dwell time × scroll depth), decision stage (how deep into the funnel they are), price consciousness (time spent on pricing vs total dwell), risk aversion (reliance on trust signals), and social influence (whether social proof drives them to act). Each dimension is a 0–1 score that updates as events are processed, typically within minutes. A reliability score (also 0–1, based on event count) tells you how much weight to give the portrait — new sessions start at 0.5 defaults and converge toward true behaviour as data arrives.

Once a session has a complete visitor profile, a nightly job assigns it to one of four audience groups: buyers (high urgency, ready to convert), researchers (high attention, thorough decision-making), deal-seekers (highly price-conscious, heavy comparison), and browsers (exploratory, low urgency). From that point, the optimizer serves segment-specific results for that audience — so buyers and researchers can have different winning variants from the same experiment. Projects with fewer than four complete profiles use device + traffic source only.

When you enable graph mode, the SDK scans the page and discovers structural and semantic relationships between your components — for example, hero → CTA → pricing. These connections are stored server-side. When a goal fires on one component, the system walks the graph up to two hops and credits related variants with a weighted share of that score. A hero headline can earn partial credit for a pricing conversion it influenced downstream. This makes the optimizer learn faster on low-traffic components by borrowing signal from high-traffic neighbours. The dashboard shows each variant's direct vs shared score split.

Yes. Wrap your root layout with <AdaptiveRoot> and list your component IDs. Assignments are resolved server-side before the HTML is sent to the browser — variants appear in the initial markup with no layout shift, no loading flash, and full crawlability for search engines.

A session is one unique visitor in a calendar month, identified by a first-party cookie (_snt_uid) containing a random UUID. If the same visitor returns multiple times in the same month, it still counts as one session. The counter resets automatically on the first of each calendar month.

Yes. The _snt_uid cookie contains only a random UUID — no personal data, no fingerprinting, no cross-site tracking. Visitor portraits are computed from anonymous behavioural signals (dwell time, scroll depth, event patterns), never from personal identifiers. If you need explicit consent before setting cookies, pass consent={false} to AdaptiveRoot or AdaptiveProvider and flip it to true once the visitor accepts. The SDK does nothing until consent is granted.

Session IDs (random UUIDs), device class, traffic source, UTM parameters, which variant was shown, goal events, dwell time per component, and scroll depth. From these signals the API derives visitor profile scores — all computed server-side from anonymous behavioural patterns, with no personal identifiers stored. No IP addresses are retained. Raw events are purged after 90 days; aggregated optimizer weights and visitor profile data are retained until you delete the project.

Yes. Use <AdaptiveProvider> from @sentientui/react in any React app — Vite, Remix, Create React App, Next.js Pages Router. Assignments are made client-side after mount in those environments (no SSR preloading), but the AI optimizer, visitor profiles, audience grouping, and graph score sharing all work normally.

New session creation returns a 402. Visitors already on your site can finish their session normally — existing sessions keep sending events, the optimizer keeps learning, and visitor profile computation continues. The counter resets on the first of the next calendar month and new sessions are accepted again automatically.

Yes. The dashboard shows accuracy ranges and significance markers for each variant. Once you are satisfied with the data, click Promote — all future traffic goes to that variant regardless of segment. You can unpromote at any time to resume optimization.

AI Insights are plain-English observations about what changed in your project this week — generated automatically from your conversion data. Every project page opens with 3–5 narrator bullets covering variant conversion rate shifts, audience velocity, session volume, and any guardrail events. Growth plans also get 1–2 advisor recommendations on what to do next. Insights are generated using Claude Haiku and cached for 6 hours. Hit Refresh to generate fresh insights at any time. Narrator and project chat are available on Starter and Growth plans (5 chat queries/day on Starter, 20/day on Growth); advisor recommendations are Growth-only.

Integration

From npm install to learning loop in 30 seconds.

~/your-app — zshready
# 1. install
$ npm install @sentientui/react

# 2. wrap your root layout (Next.js)
import { AdaptiveRoot } from '@sentientui/react/next';

# 3. drop adaptive variants where it matters
<Adaptive id="hero_cta" goal="signup_click" variants={ /* … */ } />

Transparency

What's live today vs. what's coming

Live today
  • Hosted learning API with AI optimizer per (component, audience segment)
  • Audience-aware variant assignment — device + source + audience segments
  • 6-dimensional visitor profiles + audience grouping (buyers, researchers, deal-seekers, browsers)
  • Component graph with semantic/structural edges + 2-hop score sharing
  • SSR-safe preload — zero layout shift, crawlable markup
  • Layout intelligence — persona-specific section reordering, shadow mode, and guardrails
  • Agent Content API (GET /v1/agent/layout) — structured JSON for AI agents, no extra infrastructure (Starter+)
  • @sentientui/mcp on npm — 12 IDE tools for Claude Code, Cursor, and Copilot (server keys from Starter+)
  • GDPR consent — preConsentBehavior, grantConsent(), OneTrust/Cookiebot hooks, configurable data retention
  • Cross-session identity + WYSIWYG text variants edited from the dashboard
  • Trends analytics — conversion rate momentum, audience velocity, profile shifts, and device breakdowns
  • AI insights narrator + advisor recommendations, and conversational project chat
  • Observation mode + auto-discovered goals + micro-signal score adjustments
  • Statistical guardrails, decision logs, variant lifecycle (auto-archive + restore)
  • Multi-user teams, signed webhooks (Slack, generic), Stripe billing, and data export
Coming next
  • ·Phase 4 learning policy — reward predicted from portrait + graph features, not just segment buckets
  • ·Autonomous mode — guardrail-gated promotion with no manual review required
  • ·Warehouse export of training rows (BigQuery / Snowflake)
  • ·SaaS intent templates — activation, expansion, security-review, and pricing-comparison layout packs
  • ·LLM-assisted variant copy generation (offline, user-triggered)
  • ·Full OpenAPI spec — request/response schemas on every management route
  • ·Cross-app portrait portability for network cold-start (horizon — privacy review required)
Ship intelligence, not infra

Your pages should learn who's visiting them.

Install @sentientui/react, wrap your components in <Adaptive>, and the AI optimizer, visitor profiles, and audience grouping start running on day one. No analyst. No data team. Zero ops.

See pricing
$ npm i @sentientui/react