The demo on this page is an AI agent that analyses customer health across a portfolio of accounts, diagnoses why specific accounts are deteriorating, and recommends retention interventions. It's integrated into a customer success dashboard, it knows which segment the manager is looking at, it marks up the chart, drafts messages to CSMs, and starts working the moment the page loads.
This document describes every piece that went into making that demo work. Some pieces are ours (the agent platform). Some pieces are yours (your data, your UI, your business logic). Below is the complete list of what was built on the "your side" of that line, so you can see exactly what it would take to create the same experience on your platform.
Each item is independent. You can build them in any order, and each one is useful on its own. Together they compound.
A: Account Detail Endpoint
What you build: An API endpoint that, given an account ID, returns the full account profile with engagement data and risk signals.
Most customer success platforms already have an endpoint that returns account details. The addition is engagement and risk data alongside the account profile:
- Account basics: company name, segment, ARR, renewal date, CSM, executive sponsor, subscribed products
- Usage metrics: daily active users (current vs 30 days ago, with percentage change), feature adoption percentage, API call volume and trend
- Seat utilisation: purchased vs active seats, as a percentage
- Engagement signals: days since last CSM touch, days since last executive touch, consecutive missed check-ins, open support ticket count and sentiment, NPS (current and previous)
- Risk signals: an array of diagnosed risk factors, each with a type (e.g. usage_decline, missed_check_ins, nps_decline), a human-readable detail string, and a severity (high, medium, low)
What this unlocks: The agent can diagnose why a specific account is at risk. It connects engagement signals to concrete risk factors: "TechFlow's DAU dropped 40% in 30 days, they've missed 2 consecutive check-ins, the executive sponsor hasn't been engaged in 4 months, and there are 3 open support tickets with frustrated tone. With 67 days to renewal and $183k ARR, this needs immediate executive outreach."
The agent doesn't just say "TechFlow has a low health score." It reads the engagement data, identifies the compounding risk factors, and names the intervention.
B: Cross-Account Query Endpoint
What you build: An endpoint that accepts filter, sort, and limit parameters and returns accounts matching the criteria with headline health metrics.
The agent needs to answer questions like: "Which accounts have health scores below 50%?" or "What are the highest-ARR accounts near renewal?" or "Show me enterprise accounts sorted by seat utilisation."
The endpoint returns per account: company name, segment, ARR, health score, days to renewal, days since last CSM touch, NPS, status, CSM name, and seat utilisation percentage.
This endpoint is wrapped in an MCP server: a lightweight service that makes it available as a tool the agent can call. We provide a specification and guide for building MCP servers.
What this unlocks: The agent finds at-risk accounts the CSM manager didn't know about. Instead of scrolling through a list, the manager asks a question and the agent queries across the entire book of business, identifies the outliers, and presents a prioritised list.
Combined with A, this gives you the full triage-then-diagnosis flow: the agent finds the problem accounts, then drills into each one to explain why.
C: Integrate the Agent
What you build: A <mindset-agent> element on your page and a one-line SDK initialisation call.
The agent renders in your page as a panel, a sidebar, or a full-screen experience. It runs against the Mindset platform. The agent's appearance (colours, typography) is configured to match your product's look and feel.
What this unlocks: Your CSM managers (or AEs, or CS leaders) have an AI agent available inside your product. They can ask questions, get analysis, and receive recommendations without leaving the page they're working on. The agent has access to any MCP tools you've built (A, B) and any skills and widgets configured in the Mindset Studio.
This is the foundation for D, E, F, G, and H below. Those capabilities enhance the agent, but each is optional and independent.
D: Page Actions
What you build: Short JavaScript functions that wrap actions your CS platform already supports.
In this demo, the agent can:
- Select accounts on the chart: multiple bubbles glow simultaneously, drawing the manager's eye to a cluster of at-risk accounts. Unselected bubbles dim.
- Focus a single account: the chart zooms in and a detail card appears showing ARR, health score, renewal, and NPS.
- Draft a message to a CSM: a panel slides up on the page with an editable message. The manager reviews, edits, and sends.
- Post an internal account note: same panel, different mode. The agent drafts a risk summary to post on the account timeline.
- Change the segment filter: the chart and table re-render for the selected segment.
Each of these is 10-20 lines of JavaScript. No backend changes. No deployment. The function runs in the browser, in the manager's authenticated session, using whatever your UI already uses when the manager clicks a button manually.
You control exactly which actions the agent can take, and you can vary them by page, by role, or by application state. A tool that isn't registered doesn't exist to the agent.
What this unlocks: The agent moves from advisor to actor. After diagnosing a problem, it marks up the chart to show where the problems are, then offers to draft the outreach message. The manager sees things happen on the page. The gap between "the agent told me what to do" and "I've done it" shrinks to seconds.
E: Context
What you build: A few lines of JavaScript that tell the agent what the manager is currently looking at.
In this demo, the agent knows: which page the manager is on, which segment filter is active, how many accounts are visible, and how many have been flagged. This updates live as the manager navigates.
What this unlocks: The manager changes the segment filter to "Enterprise CS." The agent picks up the new context and re-analyses without being asked. Different segment, different risk profiles, different recommendations. No reloading, no new session. The manager never has to type "I'm looking at enterprise accounts"; the agent already knows.
F: Identity and Multi-Tenancy
What you build: The customer account ID and user role, passed as headers to your MCP endpoints.
This enforces multi-tenancy: one agent serves all your customers, but each user only sees their own data. The scoping is enforced by your endpoints, not by the AI.
What this unlocks: One agent configuration serves your entire customer base. Data isolation is enforced server-side. You don't need a separate agent per customer. The same agent, the same skills, the same widgets, scoped to the right data by identity headers that your endpoints verify.
G: Programmatic Triggers
What you build: One-line JavaScript calls that send a message to the agent from your application.
In this demo, three events trigger the agent:
- Page load: the agent immediately starts analysing the portfolio. The manager doesn't type anything.
- Segment filter change: the agent re-analyses for the new segment automatically.
- Outreach sent: after the manager sends a message or posts a note, the agent is told to continue and suggest the next action.
Any event on your page can trigger the agent: a button click, a page load, a filter change, a record selection, a form submission. The trigger can be visible in the chat or silent.
What this unlocks: The application orchestrates the agent, not just the user. Proactive, event-driven agent experiences become possible without the manager needing to know what to ask.
H: Expert Knowledge (Skills)
What you build: A markdown document containing the domain expertise you want the agent to use when interpreting data.
In this demo, the agent loads a Customer Health Interpretation skill before analysing any account data. This skill contains:
- Health score interpretation: what each range means, why trajectory matters more than snapshots
- Usage benchmarks: what constitutes a "usage cliff" (>30% DAU decline in 30 days), when seat utilisation becomes a red flag (<40%), feature adoption thresholds
- Engagement benchmarks: expected check-in cadence by segment, when "days since last touch" becomes a risk signal, executive engagement expectations
- NPS interpretation: score ranges, NPS decline as a leading indicator
- Risk signal taxonomy: what each signal type means and what to do about it
- Metric combination interpretation: "high ARR + low health + near renewal = urgent" and other compound signals
- Intervention recommendations by risk type: usage cliff, champion departure, seat underutilisation, support sentiment, imminent renewal
What this unlocks: The agent doesn't guess. It interprets account data using your organisation's CS best practices. The skill is the difference between "this account has a low health score" and "this account has a usage cliff, which is the strongest leading indicator of churn, and it compounds with the missed check-ins and NPS decline to suggest the internal champion may have departed."
Skills are configured in the Mindset Studio by non-technical CS leaders. No code, no deployment. Update the benchmarks when your playbook changes.
How they compose
| Combination | What the agent can do |
|---|
| A alone | Diagnose why a specific account is at risk |
| A + B | Find at-risk accounts across the portfolio, then diagnose each one |
| C + A + B | Agent in your product, finding and diagnosing accounts |
| C + D + A + B | Agent marks up the chart, drafts messages, posts notes |
| C + E + A + B | Agent knows context, scopes analysis to the manager's current view |
| C + F + A + B | Agent serves multiple CS teams from a single configuration |
| C + G + A + B | Agent starts on page load, reacts to filter changes and actions |
| C + H + A + B | Agent interprets data using CS best practices, not guesswork |
The live demo shows all eight working together.
Summary
| Capability | What you build | What the agent can do |
|---|
| A. Account detail | One enriched endpoint | Diagnose why a specific account is at risk |
| B. Cross-account query | One endpoint + MCP wrapper | Find at-risk accounts across the portfolio |
| C. Integrate the agent | Agent element + SDK init on your page | AI agent available inside your product |
| D. Page actions | JavaScript functions wrapping existing UI actions | Select bubbles, zoom in, draft messages, post notes |
| E. Context | JavaScript on the host page | Agent knows what the manager is looking at |
| F. Identity | Headers passed to your MCP endpoints | Multi-tenant: one agent, many customers |
| G. Triggers | JavaScript calls to send messages to the agent | Agent starts on load, reacts to events |
| H. Expert knowledge | Markdown document with domain expertise | Agent interprets data using your CS playbook |
Each is independently valuable. They compose into increasingly powerful agent experiences.
What Mindset provides
Everything not listed above: the agent runtime, LLM orchestration, streaming, multi-turn conversation management, the configuration studio where non-technical admins manage agents without code, expert knowledge injection (skills), rich visual rendering of tool results in the chat (widgets), persistent memory across sessions and devices, and the infrastructure to run all of this at scale across your customer base.
You build the domain pieces that only you can build. The platform handles the rest.