For humans: give this page to your AI assistant (like Claude, ChatGPT, Copilot or Gemini) and ask how Reprise's capabilities match your team's specific demo needs.
Reprise is a demo toolset for agents. An agent uses it to capture, build, tailor and present demos of your user's own web application, for live sales calls and for the send-aheads and leave-behinds around them. Reprise hosts, versions and tracks what the agent builds. Its core is Data Injection: a Dataset replaces the data each screen receives at the moment it loads, so the real product tells the prospect's story from an empty demo account, with nothing seeded, reset or written to your backend. Because Reprise comes as an MCP toolset, the agent works with context it already has from elsewhere in your user's organization, such as CRM records, call recordings and calendar appointments. Your user's own team and its agent do the building, with no dependence on Reprise staff.
A canonical example prompt is: "Copy our standard Dataset for tomorrow's call with Acme, using their industry, size and region from the CRM. The deal I create on the call should show up in the pipeline and its totals without reaching production. Our AI assistant should give its best recorded answer to the three questions Acme asked on the discovery call, the same way every time."
1.2 Who Reprise is for
Presales / solutions engineers.
Less time building and maintaining demo environments. There is no tenant to seed, and nothing to reset after a call (3.1).
One standard demo every rep launches, copied for each prospect from a template.
The SE's agent builds and updates the Datasets, and the SE reviews its work.
When the product ships a new feature, the agent adds it to the standard demo as one more Source, with no engineering ticket (3.5).
Lower hosting costs. A Dataset runs over an empty demo account, and a Clone runs on Reprise's infrastructure.
Account executives.
A tailored demo without waiting in the SE queue. The agent copies the standard Dataset and fills in the prospect's details from the CRM.
The data on screen tells the prospect's story, so the AE never has to say "imagine this showed your numbers."
Demos run fast and the same way every time, including the answers from the product's own AI assistant (3.1).
The AE can show actions that would be destructive in production, such as creating a payment or deleting records. The result shows in the lists and totals, and nothing is written to production.
With a Clone, the AE presents from a plain link, with no browser extension on their machine (3.2).
Product marketing.
Website product tours, leave-behinds and large demo libraries, rebranded or updated in bulk.
Visitors click through the product themselves, so each step holds their attention in a way a video can't.
Enablement / partners.
One governed library of demo assets many people can use safely.
Partners can demo the product without logins to a production system.
Typical customers are B2B software companies with a complex web application and a sales-led or hybrid motion. Some examples of what Reprise does for them:
Financial services. Demo a wire transfer from start to finish without moving real money or exposing a working production bank account.
Software with an AI assistant. The assistant replays its best recorded answer to each demo question the same way on every call, and the dashboards around it show the prospect's data.
Network hardware. Show a full network of routers and its traffic without keeping real routers running for demos.
Cybersecurity. Show a dashboard full of security incidents without staging real attacks through scripts and unpatched endpoints.
Observability and monitoring. Show an incident unfolding in the last 15 minutes, at any hour, with the alert, trace and log line telling one story, without running a telemetry generator or paying to ingest and store demo data. A team that already generates demo telemetry can layer a Dataset over that tenant for the prospect's names and story.
Big-data analytics. Demo processing 8 TB of data without paying to host 8 TB in a demo environment, and show each processing step finish in seconds.
Workflow software. Keep a library of standard demo environments, one per target vertical, and copy one for each call.
Software with integrations. Demo an integration pushing data into another system, such as a CRM, without changing the real system, which sits outside the vendor's control and can't be reset after each call.
Live events. An executive presenting on stage runs the demo offline, so a weak trade-show network can't break it.
1.3 Asset types and containers
Reprise has two kinds of building blocks. Asset types are the demos themselves. Containers package assets for a buyer.
Asset types
Asset type
What it is
Typical use
Dataset (data injection)
Saved demo data that Reprise injects by swapping API responses in the browser, either into your user's real, live application or on top of a Clone. Charts, tables, KPIs and dashboards show prospect-relevant data. Turn it on for a call and off afterward.
Live calls where the real product must show realistic data; personalizing a Clone per prospect; preparing screens before a tour capture
Clone
A working, interactive replica of your user's application (front end plus captured network behavior, optionally a hosted backend) that runs on Reprise infrastructure.
Any demo where using production is a problem for a reason other than data: no production or demo environment is available, or it is too sensitive to show; it is too slow; or demo environments cost too much to maintain. Sandboxes, hands-on evaluations, trade-show and partner demos follow from this.
Product Tour
Captured HTML screens of your user's web app, stitched into a guided, clickable tour with guides (tooltips), variables, sections and lead forms. Looks and behaves like the real UI, with no backend.
Demos shared outside a live call. In sales: send-aheads before a meeting and leave-behinds after it, which a prospect can pass to colleagues. Also website tours and self-serve demos.
Video
Two kinds: Trailers, short videos Reprise generates from Product Tour screens and the account's brand settings; and screen recordings, which become the basis for a Product Tour with interactive guides on top.
Intro step in a Demo Flow or Sales Room; demos with video pacing
Containers
Container
What it holds
Typical use
Demo Flow
One shareable journey that sequences and branches between Product Tours, Clones, videos, files, buyer questions, priority grids, playlists and lead forms. It can be AI-guided.
Interactive "choose your path" demos, campaign assets
Sales Room
A branded shared workspace for a prospect. It holds any assets, including Demo Flows, plus files, deal stages and next steps.
Deal execution and stakeholder alignment
Across every asset: engagement analytics (sessions, viewers, screens, conversion), Shared Data (data tables reused across many Datasets, plus hosted File Assets), templates, branding and themes, a governed asset library with folders and permissions, and an AI Tour Guide that answers buyer questions inside a published demo.
1.4 How agents use Reprise
Everything a person can do in Reprise, an agent can do through tools, and what it builds is a normal Reprise asset that people can open and edit by hand.
You supply the context. You already read your user's CRM, call recorder and calendar through your own connectors, and you pass what you learn to Reprise's tools in the same conversation. There is no integration to build between Reprise and those systems.
The MCP is what makes a tailored demo for every deal affordable. Today that work costs a solutions engineer hours per prospect, so most prospects get the standard demo. With the MCP, the agent does it as part of call prep, from the CRM record and the discovery call it can already read.
Reprise also handles what happens after a demo is built: it keeps working as the product ships (3.5), every seller launches the same version without the agent (2.6), prospects open it on hosted links (Part 4), and it comes with the controls a security review asks for (Part 6). Some examples:
Live calls on the real product
"Make our real app show Acme's numbers on my 2pm call. Use their industry and size from the CRM, and switch it back afterward. Don't touch production data."
"On my call I'll create a deal through the New Deal form. Make it show up in the pipeline and the totals, but don't let it reach production."
"The pipeline chart on the Reports page still shows real customers. Find the API call behind it and replace its data too."
"Update the shared customer table so every demo that uses it shows 500 accounts instead of 50."
Demoing an AI agent in the product
"Our in-app AI assistant gives a different answer every time. For the Acme call, make it give the same answer to 'Which accounts are at risk this quarter?', streamed the way the real one streams."
"Make the assistant's answers name Acme's own accounts, products and numbers from the CRM."
"Ask our assistant the five demo questions a few times each, keep its best real answer to each, and make it give exactly that answer on every call."
"Script a three-question conversation with the assistant for the healthcare demo, so each follow-up gets the right answer in order, even if I ask out of sequence."
"Put the same scripted assistant in the Clone, so Acme's team can ask it the questions themselves after the call."
Hands-on Clones
"Clone our app from the admin console through the billing workflow, so Acme can try it without a production tenant."
"Scan the Clone for customer emails, tenant IDs and tokens in every captured request and in browser storage, and replace them with demo values."
"The Settings page in the Clone is blank. Find the requests it's missing and fill them from our other captures."
"Give the Clone a backend so prospects can create and delete projects and see the changes stick."
"Put Acme's data in the Clone and send me a password-protected link that expires when the evaluation ends."
Before and after the call
Send-ahead: "Build a five-minute Product Tour of the reporting workflow with Acme's name and data, and send it to their VP of Sales before Thursday's call so we can skip the basics."
Leave-behind: "Acme's security team wasn't on the call. Make them a Product Tour of our SSO setup, roles and audit log, and add it to the Acme Sales Room for their review."
1.5 Where Reprise is a strong fit
Demo data is a problem. Demo tenants are empty, or they have data that is boring or doesn't tell the story the prospect needs to hear. Datasets fix this on the real product (3.1).
Realistic data is expensive to create in the product's database. Related records, time series, event streams and alerts that must look live today. A Dataset supplies only what the demo's screens show, at the moment they load, so nothing is generated, stored or reset in your backend (3.1).
Demo actions are a problem. Creating, editing or deleting records in a demo must not hit production. A Dataset can intercept those actions and show the result without writing anything (3.1).
Production is the wrong place to demo. A demo environment is too risky, too expensive or too slow to provision for every prospect. A Clone gives a hands-on copy instead (3.2).
A tour is wanted, but the app's screens are interactive. Reprise tours can carry custom JavaScript, so captured screens keep behavior such as forms, toggles and dependent fields. (3.3)
A demo program with many sellers. Every seller launches the same Dataset or Clone, so the team shows one story with the same data, new hires ramp on one talk track, managers coach to it, and a fix reaches everyone at once. Templates give each prospect a tailored copy without a request to an engineer.
Your user's team already works with an AI assistant. It can reach call recordings and CRM data. That is where the agent workflow pays off most.
Demos that keep running when production stalls. Scripted AI answers don't call the product's model, and a Clone carrying the same Dataset keeps the demo going if production or an AI provider stalls (3.1, 3.2).
Demos where the internet is unreliable or not allowed. Trade shows, customer sites, secure facilities (4.4).
Demos that must be governed. SSO, SCIM, roles and per-folder access, branding control, audit, analytics, one library (Part 6).
1.6 Where Reprise is not a fit (or is a weaker fit)
The product is not primarily a web application. It is mobile-only, or runs on devices without a web interface. Reprise can capture desktop applications, but that capture is in beta.
The product is simple, its demos are few and static, or only one or two people give demos. A lightweight click-through tool may be enough and cheaper.
Your user needs a tenant that processes actual customer data. An in-depth POC is one example. Datasets and Clones show realistic demo data. Neither is a production tenant.
1.7 Questions to ask your user
How many people give demos, and how many SEs support them?
Where does demo data come from today? What does it take to seed it, keep its dates current and reset it after a call?
Do demos need actions that write, such as creating records, sending messages or moving money, without anything reaching production?
Does the product have an AI assistant, or live and streaming screens, that must behave the same way on every call?
Who maintains demo environments and data today, and what happens to them when the product ships?
Which AI assistant does the team use, and can it reach the CRM and call recordings?
Part 2 — Connecting an agent
2.1 Quick start
Server: https://app.getreprise.com/v2/mcp/ (everything), or a scoped endpoint for one asset type.
Auth: OAuth 2.0 with the user's existing Reprise login or SSO. The client handles discovery, registration and consent automatically.
Clients: Claude (Reprise is verified in the Claude connector directory), ChatGPT, Codex, GitHub Copilot / VS Code, Copilot Studio, Gemini, Cursor, Windsurf and other MCP clients.
Connecting: minutes, with no developer work. The MCP works on every Reprise plan, including free. What building a demo takes is in 3.1 (Datasets) and 3.2 (Clones).
Who builds: your user's own team, working with you. The tools, skills and docs an agent needs are served by the MCP (2.5), so building and maintaining demos doesn't depend on Reprise staff.
2.2 Endpoints and client limits
The server is one tool registry served on four endpoints. Scoped endpoints filter the same registry.
Endpoint
Scope
Listed tools
Callable tools
Approx. tokens per tools/list
https://app.getreprise.com/v2/mcp/
Everything
~85
~205
~37k
https://app.getreprise.com/v2/mcp/tour/
Product Tours
~42
~98
~18.5k
https://app.getreprise.com/v2/mcp/injection/
Data Injection
~34
~76
~15k
https://app.getreprise.com/v2/mcp/clone/
Clones
~27
~62
~10k
The gateway and the core platform_* tools are on every endpoint. Pick the smallest endpoint that covers the task. Many clients cap tool counts and silently drop tools past the cap:
Client
Approx. tool cap
Recommended endpoint
Claude Code
no low cap
/v2/mcp/
Claude Desktop
~100 per server
one scoped endpoint
Codex (CLI, ChatGPT desktop, IDE)
none documented; 60-second default tool timeout
one scoped endpoint. Raise tool_timeout_sec to ~300 and startup_timeout_sec to ~30
GitHub Copilot / VS Code
128, shared across all servers
one scoped endpoint
Gemini CLI
512
/v2/mcp/
Gemini (Vertex)
128
one scoped endpoint
Windsurf
100, shared across servers
one scoped endpoint
Cursor
~40
/v2/mcp/clone/ or /v2/mcp/injection/
2.3 Transport and authentication
Transport: streamable HTTP.
Auth: OAuth 2.0 authorization code with PKCE (S256) and Dynamic Client Registration (RFC 7591).
The server publishes OAuth discovery metadata, and every 401 carries a WWW-Authenticate challenge pointing to it. Standards-following clients configure themselves; there is nothing to pre-register and no token to paste.
Loopback redirect URIs are supported for desktop and CLI clients.
Identity: the user signs in with their normal Reprise login, through SSO if their account uses it, and sees a per-user consent screen.
Tokens:
Access tokens last 1 hour and refresh tokens 30 days. Refresh tokens can be revoked.
A user's tokens stop working the moment the user is deactivated, whether in Reprise or through SCIM. SCIM deactivation and deletion also revoke them outright.
Network: egress to app.getreprise.com:443 over TLS.
2.4 The gateway: every operation through four tools
Listing every capability as its own tool would overflow client tool caps and degrade tool selection. Reprise therefore lists a compact head of ~85 tools and exposes the rest through a four-tool gateway.
Three numbers, three things. About 85 tools appear in a client's tool list. About 205 tools can be called by name. The gateway catalogs 393 operations, because many tools take several actions: one tool that can create, update or delete a record counts as three operations. Every operation is reachable through the four gateway tools:
Tool
Purpose
platform_api_search(intent, resource, limit)
Find operations by what you want to do and what it acts on, e.g. intent="restore", resource="dataset"
platform_api_details(operation_id)
Full parameter documentation for one operation
platform_api_read(operation_id, parameters)
Run a read-class operation
platform_api_write(operation_id, parameters)
Run a write- or destructive-class operation
How it behaves:
Parameters are JSON. Pass parameters as a JSON object string, e.g. '{"draft_id": "..."}'.
Reads and writes are separate executors. Every operation is classified read, write or destructive, and classification is fail-closed: an action not known to be a read is treated as a write. A client can therefore auto-approve platform_api_read and require confirmation for platform_api_write.
Same controls as the listed tools. Gateway calls run through the same permission checks, tenant isolation, audit logging and usage limits.
2.5 Core tools and tool design
Platform tools. platform_whoami, platform_skill, platform_docs, platform_highlight_set / _clear (outline elements on the user's live tab), and the four gateway tools.
Account-wide gateway operations.
Library: folders, moving assets, reading and setting folder access lists.
Account: brand, AI Tour Guide avatar, voice and guidance, AI spend settings, workspace roles.
Account memory: notes the account keeps for its agents across sessions and colleagues.
Governance: audit log.
Atomic, intent-named tools. Reads and writes never share a tool. Tools carry MCP readOnlyHint / destructiveHint annotations, so clients can auto-approve reads and ask before writes or deletes.
Skills and docs are served by the server.
platform_skill(slug) returns procedural playbooks. Start with reprise-mcp, the router.
platform_docs(slug) returns product guides and searches the help center.
MCP resources (skill://, docs://) are offered to clients that support them.
Some complex writes are gated until the relevant skill has been read in the session, so agents don't guess at configuration.
Untrusted-content marking. Content captured from customer applications (HTML, network data, code, guide text, notes) and text written by Demo Flow visitors, such as what they told the AI guide, comes back wrapped in <untrusted-content> delimiters, so your runtime can handle it as untrusted data. This is defense in depth against prompt injection; the agent runtime remains the primary control.
2.6 The browser extension and desktop app
Browser extension (Chrome)
The Reprise extension for Chrome is where Reprise touches your user's real app in their browser. It installs from the Chrome Web Store.
For agents: capture, inspection and injection.
The MCP pairs with the extension in the user's browser. The agent then starts and stops captures of Product Tours and Clones, inspects the page and its network traffic, and turns Datasets on and off on the live app.
Pairing starts from the MCP, which returns a one-click pairing link for the user to open in their browser.
For users: one-click demos. A seller opens the extension and launches a demo, with the right Dataset turned on, in one click.
A built-in agent. The extension also includes an agent hosted by Reprise, with the same toolset as the MCP. A user without their own AI assistant can ask it for the same work in the browser.
Desktop app
For capture and demos outside Chrome, Reprise provides a desktop app.
Capture beyond the browser (beta). It records another app on the same computer into a Product Tour.
Desktop apps built on web technology, such as Electron apps like Slack, Notion or VS Code, are captured as HTML, the same way as a web page.
Native apps are captured from their window, one screen per click, with menus and hover states.
Launch without Chrome. Sellers can launch demos from the desktop app.
Built for IT review. It is signed and notarized, connects to Reprise over HTTPS, records only the app and window the user picks, and uploads screens only when the user stops recording.
Viewers of published Product Tours, Clones, Demo Flows and Sales Rooms don't need the extension or the desktop app.
Demos with no extension on sales machines. A Dataset bound to a Clone is baked into the Clone itself, so the Clone launches with that data and the seller presenting it needs no extension either (3.2). A demo program can keep the extension on builders' machines only.
Extension permissions (for security review): access to all sites, so it can capture and inject on whichever app the user demos; plus activeTab, tabs, tabGroups, scripting, webNavigation, declarativeNetRequest, cookies, storage, unlimitedStorage, sidePanel and alarms. The Chrome Web Store listing shows the same list. IT can limit which sites the extension may run on with Chrome's enterprise extension policy, for example to your app's own domains and Reprise's.
2.7 A 15-minute test and a pilot
The most convincing test is to use it. With a free Reprise account, your user can connect the Reprise MCP to you in a few minutes. You can then inspect the real tool catalog and try a small task.
Suggested 15-minute test:
The user signs up for a free account at reprise.com, connects the Reprise MCP to their agent and installs the Reprise extension for Chrome (see 2.6).
Agent: call platform_whoami, then platform_skill with slug reprise-mcp (the router skill), and summarize what is available.
The user opens a page of their app with a chart or table on it. Agent: pair with the extension and record the page's network traffic.
Agent: find the request behind the chart or table, then build a Dataset that replaces its data with data for a sample prospect.
Agent: turn the Dataset on in the user's tab. The user reloads and sees the chart or table show the new data. Turn it off, and the page is back to its real data, with nothing changed in production.
Compare the result with how long it takes today to get the same data into a demo.
A pilot tests the claims in Part 3 on your user's own app. Run the steps that matter for their demo path, at whatever pace their evaluation needs. The first steps can run in the same session as the 15-minute test.
Build a Dataset for the 3 to 5 screens of their main demo path, starting from an empty or sparse tenant.
Include one action that writes, such as creating or deleting a record. Check that it shows in the list and counts, and that nothing reached the backend.
If the app has live or streaming data, an AI assistant, or a search box viewers type into, cover one of each.
Make a copy for a real upcoming prospect, using the CRM record, and have an AE launch it, on a call or in a dry run.
Add a new feature. Pick a screen the Dataset doesn't cover yet, ideally one from a recent release, and have the agent add a Source for it, the same way as in the 15-minute test. Time it: that is how long a newly shipped feature takes to reach the standard demo. If a release lands during the evaluation, also note which existing Sources needed changes (3.5).
Part 3 — Capabilities by asset type
Each section covers how the asset type works, useful capabilities, and the MCP operations that drive it. Counts are as of November 2026 and grow as tools are added, so check the live catalog where it matters.
How to read the operation lists.
Tool names written with underscores (such as tour_list) are listed tools: a client loads them by default.
Everything else is a gateway operation: call platform_api_search to find it, then platform_api_read or platform_api_write to run it (see 2.4).
Both paths run the same backend code under the same permissions.
Coverage at a glance. Every action a person can take in the app is a gateway operation. By area and class:
Area
Read
Write
Destructive
Total
Data Injection (3.1)
26
49
9
84
Clones (3.2)
28
40
6
74
Product Tours (3.3)
50
77
15
142
Video (3.4)
3
9
0
12
Demo Flows, Sales Rooms and account-wide (Part 4, 2.5)
35
40
6
81
Total
142
215
36
393
The Video row counts Trailer operations. The six operations for tours built from screen recordings are counted under Product Tours.
3.1 Data Injection (Datasets)
What it is technically.
What a Dataset is. A Dataset is saved demo data that Reprise injects into a running app. It works in two places:
Your user's real, live web application. When the Dataset is active, the app shows the Dataset's data in the user's browser. The app's code and backend are untouched.
On top of a Clone. Bound to a Clone, the Dataset is served by the Clone itself and personalizes it per prospect without recapturing (see 3.2).
Sources. A Dataset contains Sources: each one says which of the app's requests it covers and what data the app gets back.
Demo data is applied where it is used. A Dataset replaces the response a screen receives, after the app's backend has assembled it and just before the app renders it. It supplies only the fields those screens display.
Nothing is written to the app's database. There are no related records to create, no foreign keys or business rules to satisfy, no background jobs, alerts or emails set off by synthetic rows, and nothing to clean up after the call.
Seeding a demo tenant is a different job. Every record has to exist with all the records it relates to, consistent across the database, whether or not the demo shows them. A mismatch can break application logic on a screen the demo never meant to touch.
The tenant underneath can be empty. Reprise builds Sources that fill empty responses, so the Dataset supplies everything on screen and the tenant needs no demo data, seeding or resets.
Or layer over an existing tenant. A Dataset changes only the requests it covers, and everything else reaches the app. Keep an existing demo tenant, or data from your user's own pipeline, for open exploration, and use a Dataset for the screens that carry the prospect's story: their names, their numbers, the incident or result they should see.
Useful capabilities
Datasets are built for the cases that make a live-app demo hard to keep reliable. Most only show up while the real app runs: sessions that expire after a timeout, security tokens that change on every request, charts windowed to the real clock, real devices that must not receive demo traffic. Others are about consistency: data the app receives encrypted, compressed or in a non-JSON format; streaming and WebSocket data, such as live dashboards and AI assistant replies; grids that page, sort and filter across thousands of rows with totals that match; and a record created on screen that has to appear in the list, the count and the detail page.
Demo on the real product or on a Clone. On the live app, prospects see the actual application with industry-relevant data, which suits live calls, POCs and preparing screens before a tour capture. On a Clone, the same Dataset approach tailors a shared, hands-on environment to each prospect.
Demo workflows on the live app without writing to production.
Writes never reach production. A Source can block a request, so an action such as creating, editing or deleting a record never reaches the production backend.
The result still shows. The Dataset answers the request itself and adds the result to the data it is showing. A record created through a form then appears in the list, the counts and the detail page.
Nothing is saved. The prospect sees a full create-edit-delete workflow complete in the real product. Turn the Dataset off and none of the actions its Sources blocked was ever saved. Cover each write on the demo path with a blocking Source. Step 2 of the pilot in 2.7 checks one.
Block every other write. One catch-all Source can block every write to the app's API that the Dataset's other Sources don't cover, and answer it with a neutral response. It lists the paths it lets through to the other Sources, and that list grows as Sources are added.
Agent-built Datasets from recorded traffic. The agent records the app's network traffic, inspects and analyzes the captured requests, and builds Sources and response templates from them. The user doesn't have to know the API.
The agent writes the demo data too. Describe the story, such as an outage at 2:13, three at-risk accounts or a region's numbers, and the agent fills the Sources and Shared Data tables. Lookups and aggregates keep related views and totals in step with the rows.
How long it takes. Measure it on your user's own app. The 15-minute test in 2.7 shows how long the agent takes to cover one page. A demo path is built the same way, one page at a time, so step 1 of the pilot gives the figure for the whole path. A per-prospect copy is a duplicate plus variable changes.
Variables.
Time that moves with the clock. Timestamps are stored relative to now, down to the minute, so "last 15 minutes", a live event feed, this week's activity and this quarter's totals look current on every call. No generator runs between calls and nothing is re-seeded.
A row in a database keeps the timestamp it was written with. A tenant seeded on Monday shows Monday's activity on Friday unless the seed is re-run or the data shifted. A Dataset computes its timestamps when the screen loads.
Set slots for customization. Values such as the prospect's name, industry or region go in predefined places, so a per-prospect copy changes only the variables.
Stateful demos.
Dataset variables also hold runtime state, such as counters, a selected entity or progressive reveals.
Rules can set and read them, so clicks change what later requests return. The data reacts to the presenter.
Shared Data tables.
One row set feeds many Sources and many Datasets.
Query mode makes grids page, sort and filter over the whole table.
Searches the viewer types are answered from the same table: a search box's query filters its rows, and an adapter can apply a query language to them. A record the story depends on is still there when someone searches for it.
Aggregates compute KPI tiles from the same table, so totals match the rows.
Tables have version history and restore, lookups and column formats.
Real-time data. Datasets cover WebSocket and event-stream data as well as ordinary requests, for live dashboards, chat and streaming UIs.
Repeatable answers from the product's AI assistant. A Source matches on the question in the request the app sends to its AI, so each question gets the same answer on every call, streamed the way the real assistant streams, in whatever order it's asked.
The answers are recorded from the real assistant. While building, the agent asks the real assistant each demo question, as many times as it takes, records the streamed replies, and saves the best one as that question's answer. On every call the Dataset replays that recorded reply, word for word. After a model or prompt change, the agent records the questions again the same way.
One answer covers many phrasings. A Source's conditions test the request body, so one answer can match the different ways a presenter or prospect asks the same question:
payload with test: "regex" runs a JavaScript regular expression against the request body. A pattern such as (at[- ]risk|churn|leav(e|ing)) catches "Which accounts are at risk?", "show me customers likely to churn" and "who might be leaving us this quarter". test: "key" checks one field of a JSON or form body, such as prompt, with contains, equals or regex.
function runs a short JavaScript function that receives the request, for matching a pattern can't express: lower-casing and stripping punctuation, checking a synonym list, or requiring two of three keywords.
Conditions combine, so a Source can also require the right screen, account or step of a scripted conversation.
You choose what happens to everything else. A question no Source matches either goes to the real assistant as a live AI call, whose answer reflects the data that call sends, or gets a default reply from a catch-all Source, such as steering back to the demo story, so nothing on the call reaches the live model.
Scripted answers don't depend on the product's model. A Source that answers a question serves the reply itself, without calling the product's AI or its provider. A slow model, a rate limit or a provider outage doesn't affect it.
Adapters. Apps whose data isn't plain JSON, including encoded, compressed or encrypted data, can still be injected.
Overlay edits. Text find/replace, image swaps, link redirects and style changes on the live page, applied alongside the data. Use them for branding, hiding a menu or relabelling a feature.
A tailored copy per prospect, stored and ready to launch.
A builder or agent duplicates a template Dataset and sets its variables (name, industry, size, region). The copy is saved in the library with versions and snapshots.
The AE launches it from the extension in one click on the call. Nothing has to be fetched, edited or tested at call time.
A copy is independent of its template. A fix to the template reaches copies made after it. For copies already made, the agent applies the same change with Dataset-wide find/replace or by copying the fixed Sources across.
Bulk data operations. Dataset-wide find/replace, CSV import and export, and copying Sources between Datasets.
The data stays portable. A Dataset exports to a file, and its tables to CSV, at any time.
Safety net. Dataset snapshots with restore, each showing who took it and when. Before an agent changes a Dataset, Reprise saves a restore point automatically, and adapter code and Shared Data tables keep their previous version. Deleted Sources can be restored with their rules and values.
In production
Examples from customer accounts as of November 2026:
A whole fleet on the live product. A telematics customer injects a full fleet into its real, logged-in app: dozens of linked tables (drivers, vehicles, trips, inspections, safety events), more than a thousand rules in one Dataset, and every timestamp relative to now. Trucks drive real road routes on the live map from scripted realtime updates, the real devices are kept out of the demo, and the user's edits are answered without reaching production. Industry variants share one template, so an AE picks the prospect's industry before a call.
Every view agrees. For a brand-protection customer, one inventory table of several hundred rows feeds the grid, its filters, the summary tiles and a CSV export, backed by hundreds of hosted screenshots. A multi-step takedown workflow advances on the seller's own clicks and can be reset for the next call.
Tailoring at AE scale. A franchise-software customer's AEs made more than a hundred prospect-specific Datasets in five months, several a week, each named for the prospect. The per-call change is the data. The wiring was built once.
Overlay edits: create, rename, add or update text, image, link and style replacements, remove, delete.
Analytics: Dataset usage sessions and viewers.
3.2 Clones
What it is technically.
A Clone is a working, interactive copy of your user's web application, made from a capture of the real app.
It runs on Reprise infrastructure, so prospects get a hands-on environment without a real tenant.
When a Clone fits. Datasets fix the data in a demo. A Clone fits when the problem with demoing on production is something other than the data:
Availability or sensitivity. There is no demo tenant, production is not safe to show, or it can't be handed to a prospect to explore.
Speed. The real app is slow to load or to run the workflow being shown. A Clone serves captured responses, so it runs fast.
Cost. Keeping demo environments running, seeded and reset after every call costs more than it is worth.
No extension on sales machines. A Clone launches with its bound Dataset already baked in, so sellers and prospects open it as a plain link. Only the people who capture and build need the extension. This suits IT teams that won't approve a browser extension for every seller.
A standby for live calls. A deploy, a slow dependency or a third-party AI outage during a call can stop a demo, even when monthly uptime looks good. A Clone loads from Reprise's CDN and makes no calls to the product's servers while the viewer clicks (4.5), and it can carry the same Dataset as the live demo. Keep its link open beside the live app. If the real product stalls mid-call, the AE switches tabs and continues with the same data.
Useful capabilities
Clones with a real backend. An agent can give the Clone a hosted backend with its own data. Users can create, edit and delete records and see them persist in their session.
Agent-driven capture and repair.
The agent pairs with the Cloning extension, starts and stops captures, and checks what was captured.
When a page is blank or broken, it finds what's missing and fixes it, with the same diagnostics an engineer would use.
Borrow data across captures. Gaps in one capture can be filled from other captures of the same app.
Sensitive-data scan and scrub.
A capture is scanned for secrets, tokens, tenant IDs, emails, IPs, usernames and hostnames.
Emails, IPs, tenant IDs and usernames can be replaced throughout the Clone, and the scrub can be reverted.
Data Injection inside Clones. Bind a Dataset to a Clone to personalize it per prospect without recapturing.
Launch parameters. Vary a Clone each time it opens.
Versioned builds. Build versions can be listed and restored, and Clones archived and restored.
In production
Examples from customer accounts as of November 2026:
One workshop Clone across a product suite. A security-suite customer's training Clone spans dozens of origins and thousands of captured requests, including sign-in between several of its products. The fixes it needed became a reusable starter pack, applied to each new product Clone.
A shared library across a portfolio. One customer maintains hundreds of Clones of its product suite from one library of fixes and features. One addition runs on about a hundred Clones, and a language switch runs on every regional variant. A fix made once reaches every Clone that uses it.
MCP operations (74)
Clones: clone_list, clone_get, clone_path_get. Gateway: create, duplicate, rename, archive, restore, launch parameters, bind or unbind a Dataset, publish a share link.
Backend: clone_author_* tools to create, edit, validate, save and publish a Clone's backend. Gateway: build versions and restore.
Data hygiene: sensitive-data scan, scrub and revert.
Notes and analytics: Clone notes, Clone analytics, viewer engagement.
3.3 Product Tours
What it is technically. The Reprise browser extension captures the rendered HTML and CSS of each screen of your user's web app. The desktop app captures desktop applications the same way (beta, see 2.6). A tour replays those snapshots as a guided, clickable demo. Nothing calls your backend at view time, so a tour is safe to put on a website or send to a prospect.
When a Product Tour fits. In sales, a tour is the asset a prospect views without a seller present:
Send-ahead. Shared before a call, so the prospect arrives having seen the product.
Leave-behind. Shared after a call, so the prospect can replay what they saw and forward it to colleagues who weren't there.
Useful capabilities
Custom JavaScript and CSS on a tour.
A tour can run custom JavaScript inside the captured page, so its screens keep their interactive behavior.
Use it for working tabs and accordions, form behavior, wizards, calculators, conditional content, or any interaction CSS alone can't do.
An agent can write the script, preview the tour in a headless browser, click the element and read back what the script logged, before anyone publishes.
Example: capture each step of a setup wizard once. Then add a tour-wide script that keeps which options the viewer picked, shows or hides the fields that depend on them, and validates required fields before the Next button works. The viewer gets a wizard that responds to their choices, all without a backend. Branching that needs real saved data is a job for a Clone (3.2).
Captured interactions. Hover highlights, focus styles, tooltips, hover menus and flyouts, and tab selections are captured with the screen. They can be switched on, pinned or re-labelled per screen, so the tour behaves like the real product.
AI-product demo effects. Typewriter effects type a prompt into the UI, streamed-reply effects reveal an answer character by character, and reveal effects fade elements in on their own step. Effects can be chained. This is built for demoing AI and chat features, where a static screenshot can't show the experience.
Personalization with variables.
Text, color, date and image variables are inserted into screens and substituted per launch link.
One tour can therefore show "Acme" to Acme and "Globex" to Globex, with their logo.
Date variables keep captured screens looking current, so a tour captured months ago still shows recent dates.
Bulk insert covers a whole screen in one call. "Materialize" bakes the values in.
Multi-language publishing. A tour can carry a language-variation catalog and be published in several languages. An agent can translate all visible text and guides.
Bulk editing at scale.
Find/replace and DOM edits work across screens.
Batch transforms apply a selector-based change across a tour with a dry-run preview and automatic backup and restore.
Theme changes restyle every tour on the theme at once.
Templates. A template tour's screens are copied into other tours and stay linked, so later changes to the template reach them.
Tours from screen recordings. A tour can be made from a screen recording, with guides pinned to moments in the video, frame lead-ins and trim (see 3.4).
Device frames. Phone and tablet bodies and backdrops, per screen or tour-wide.
AI Tour Guide. An AI guide answers buyer questions inside a published tour, using knowledge generated from the tour's screens.
It can be given an avatar, a voice and account-level guidance.
With drivable tours, the guide can also move the viewer through the tour.
Quality checks. Screen health checks, launch-link probes (opening the shared link headlessly) and debug sessions catch broken demos before a prospect does.
MCP operations (142)
Find and create: tour_list, tour_get, tour_search, tour_create, tour_duplicate, plus import (file or URL), export, content search.
Capture: tour_capture_session_start / _status / _stop, tour_capture_now, tour_capture_draft_select, tour_capture_toolbar_mount. Auto-capture mode and wait-for-idle are gateway operations.
What it is technically. Reprise supports two kinds of video:
A Trailer is a short video Reprise generates from the account's Product Tour screens and brand settings.
A screen recording of the app becomes the basis for a Product Tour, with interactive guides on top of the video.
Useful capabilities
Generated product videos from the account's existing demos.
An agent starts a Trailer, picks the tours, writes the request, plans the shots, edits individual shots, makes the video and approves it.
Versions keep the same tours and request when a change is needed.
No screen recording or video editor is involved.
Use anywhere in the funnel. Approved Trailers play as a step in a Demo Flow (usually the first) or as an asset in a Sales Room.
Screen recordings as interactive tours. Turn a recording into a tour with guides at specific moments, lead-ins into each frame and trim. The viewer gets video pacing with tour interactivity.
MCP operations (12 Trailer + 6 screen-recording)
Trailers: start, list, get, tours, set request, plan shots, set shots, edit a shot, make video, approve, new version, rename.
Screen recordings: create a tour from a recording, get, frame update, frame delete, guide at a moment, trim.
3.5 Keeping demos current
Products change every sprint. Here is what each asset type does when they do:
Datasets run on the shipped product, so the demo always shows the current UI.
A new feature is one more Source. When a release adds a screen that needs demo data, the agent opens it in the paired browser, records its traffic, builds a Source for the requests behind it and adds the Source to the template Dataset. This is the step the agent used to build the Dataset in the first place, so it takes about as long as covering one page did in the 15-minute test (2.7). Your user's team does it themselves, with no ticket to Reprise or to their own engineers. Copying the new Source into a prospect copy still in use is one call per copy. Until the Source exists, the new screen shows the demo tenant's own data.
A changed response means a Source update. Existing Sources need work only if a release changes the shape of a response they cover, such as a renamed field or a new required value. UI changes, and database or schema changes behind an unchanged API, pass through untouched. injection_source_list returns the request each Source covers, so comparing it with the release's API changes shows which Sources, if any, need work.
Rebuilding a Source. The agent records the page's traffic again and rebuilds the Source. Snapshots let you roll back. Fix the template first, so later prospect copies inherit the fix, and have the agent copy the rebuilt Source into existing copies that are still in use.
Product Tours are snapshots, so they don't change when the product does. That keeps a send-ahead stable, but tours age.
Recapture or edit. Recapture changed screens, or find and replace across a tour or the library.
Templates. Template tours (3.3) are linked: update the template once and every tour built from it gets the change.
Checks. Screen health checks and link probes catch broken tours before a prospect does.
Clones are captures too. Recapture the changed paths; gaps can be filled from other captures, build versions can be rolled back, and the agent diagnoses blank or broken pages with the same tools it used to build the Clone.
3.6 Known limitations and caveats
The best-tested agent experience is with Claude and Codex. Other MCP clients work within their own tool caps and approval models (see 2.2).
Capturing Clones, and playing Datasets on a live app, use the Reprise browser extension (Chrome). Product Tours can also be captured with the desktop app, which captures desktop applications in beta. A Clone serves its bound Dataset itself, so people viewing the Clone need no extension.
Some operations are long-running, such as capture inspection and Clone backend authoring. Raise client tool timeouts where the client allows it.
On a live app, a Dataset changes only the requests it covers. Everything else reaches the account the browser is signed in to: an uncovered screen shows that account's data, and a write that isn't blocked is saved there. A catch-all Source (3.1) blocks the writes no other Source covers. If the extension's interception stops answering for 5 seconds, requests go to the network as normal. So demo from a demo account. The demo account can be empty (3.1). Then an uncovered screen shows an empty state, a stray write lands in an account no customer uses, and there is no seed data to keep or reset. Walk the demo path once after building a Dataset, and again after a release that changes the screens it covers. You can do the walk yourself, with no one at the keyboard: Reprise's tools turn the Dataset on in the paired browser, your own browser tools click through the path, and while the Dataset plays, injection_capture_inspect with action trace lists the recent requests on the tab that no Source covered, so the walk shows what is still uncovered.
Data injection works on what the browser receives from the app's API. Apps that render server-side without API calls suit a Product Tour or Clone better.
Some capabilities depend on plan (see the plans page in 7.1):
Every plan, including Free: the MCP, Data Injection on a live app with unlimited Datasets, and Product Tours.
Teams and up: Demo Flows and Sales Rooms. Teams costs $125 per Builder seat per month, or $100 per seat per month billed yearly.
Growth and up: custom CSS and JavaScript on tours, Presenter seats for people who only present (priced below Builder seats), hosted File Assets and offline Product Tours.
Enterprise: Clones (including Data Injection inside them), the offline Clone player, SSO, SCIM, fully custom roles with folder-level access, custom domains, and the Data API (5.3).
AI-guided flows and video: see the plans page.
Plans and prices are on the plans page (7.1). Growth and Enterprise are quoted by your user's Reprise rep. A pilot of Data Injection on your user's own app (2.7) needs only the Free plan.
Part 4 — Presentment: delivering demos to buyers
How demos reach buyers: shared as links or embedded in web pages, packaged in Demo Flows and Sales Rooms, played offline, and served at scale.
4.1 Links, embedding and guidance
A published Product Tour is shared through a link. Each link sets where the demo opens and what guidance the viewer gets, so one tour can be shared several ways.
Where it opens
Launch Room: Reprise's viewer page, with the demo inside it.
Embedded (direct link): the demo opens full screen, with no Launch Room around it.
Reprise generates embed code to paste into any web page, such as a product page, a help center or an LMS, with size, border, corner and shadow options.
A link can be limited to listed domains, so the demo plays only inside pages on those sites. The browser enforces this. It stops a shared link from playing elsewhere. The access controls in 6.7 still apply.
Guidance for the viewer
Guided tour: the tour's authored guides, shown as step-by-step popups.
Narrated tour (Narrator Mode): the same authored guides, played hands-free with an audio voice-over, optionally with a video avatar. It is the most common mode that isn't AI-driven: the audio holds attention better than popups the viewer has to read.
AI Tour Guide: answers the viewer's questions live, optionally with a video avatar that voices the answers (see 3.3).
No guidance: the viewer clicks through the tour freely.
A link can also turn on the tour's sections menu, and presenter notes for a seller presenting it live.
For agents: tour_link_read and tour_link_write read and set a link's guidance and settings.
4.2 Demo Flows
What it is technically. A Demo Flow is one shareable link that plays several assets. It plays assets that already exist and doesn't capture the app itself. It comes in two kinds:
Scripted: a graph of steps with branching.
AI-guided: an AI guide talks with the visitor and opens Product Tours and videos from an asset pool as the conversation goes.
Useful capabilities
Branching, personalized journeys.
Scripted flows mix Product Tours, videos (Trailers, Reprise-hosted and external), files, web pages, questions, priority grids, asset lists, lead forms and closing messages.
Answers and grid outcomes route the visitor.
Playlists let the visitor open a set of assets in any order, ranked by weights that earlier answers adjust.
AI-guided flows.
A conversational guide runs discovery (what to learn, approved answers, opening, pitch, glossary) and opens the right asset for what the visitor says.
Setups can be saved as discovery templates and reused across flows.
Buyer insight. Flow analytics include step-by-step paths (Sankey), question and grid answers, playlist plays, per-visit detail and visitor insights across flows.
Room controls. Who may open a flow's link, its welcome page and its header call-to-action.
Flow analytics (7): overview, per-flow, visits, single visit, visitor insights, visitors across flows, video in flows.
Hosted File Assets (5): host a file from a URL or an upload, label it, list it, get it. Use these for video and file steps.
4.3 Sales Rooms
What it is technically. A Sales Room is a branded, prospect-facing workspace for one deal. It holds Product Tours, Clones, Demo Flows, videos, files and links, with a deal-stage timeline.
Useful capabilities
One place for the deal. Every demo, file and next step for a prospect sits behind one link, branded for them.
Deal stages. A timeline the account defines, which a room moves along as the deal progresses.
A named owner. The room shows the prospect who their contact is.
Account-wide defaults. Default assets, such as a security overview or a case study, appear in every new room.
Per-room styling. Each room sets its own styling for the viewer.
One switch to close access. Archiving a room stops all its links.
MCP operations (25)
Rooms: create, update, set owner, set stage, archive.
Reprise demos can run with no internet connection. That works at trade shows, on customer sites with locked-down networks, in secure facilities and on flights.
Offline Player. A desktop app for macOS, Windows and Linux that plays Product Tours and Clones offline. Clones keep their interactivity, because the Clone runs locally.
The library, synced. When the player is online and signed in, it lists every published Product Tour and Clone the user can see, in the same folders, under the same permissions as the web library.
Download a demo once, then play it anywhere.
Republished demos update in the background, at launch, every 30 minutes and when the network comes back. Auto-update can be turned off.
Copies are removed at the next sync if the user loses access, so revoking access also reaches offline copies.
Built safely.
Sign-in uses the same OAuth flow as the MCP, and tokens are stored encrypted.
Downloads come only from Reprise's own storage over signed links, are checked for size and checksum, and resume if interrupted.
Each demo plays in a sandboxed window, served from the user's own computer only (127.0.0.1).
Who can use it. Downloading needs the Export permission and an account with offline exports.
For agents. An agent can start an offline export of a Product Tour and hand the user the download (TourExport with self_host, then TourExports).
4.5 Hosting, availability and scale
Demo content comes from a CDN. Published Product Tours and Clones load their screens, scripts and assets from a content delivery network. When a viewer opens a link, Reprise checks its access rules (welcome page, password, allowed emails or domains, IP allowlist, expiry). The demo content itself comes from the CDN.
Clones run in the viewer's browser. A Clone loads from the CDN and makes no calls to Reprise's application servers or database while the viewer clicks around.
Clones keep working during an outage. If Reprise's application servers fail to answer, with an error or no reply within 8 seconds, an edge service serves published Clones from the CDN instead.
It still checks passwords and email allow-lists, and still lets in signed-in users for Clones that need sign-in.
Viewer analytics are queued and delivered once the servers are back.
This failover is turned on per account.
Load tested at scale. Clone serving was recently load tested to 100,000 concurrent sessions.
Custom domains. Demos can be served from the customer's own domain (for example demo.yourcompany.com).
Part 5 — Usage data
Reprise records how buyers and sellers use each demo. This part covers where to read that data and how to send it to other systems.
5.1 In-app analytics
Product Tours: sessions per day by status, link and version, unique viewers, offline sessions, and funnels by screen, step and path. Each session has a timeline of what that viewer did.
Clones: sessions and viewers per Clone, per page and per signed-in user, with page views, clicks, form submits and active time. Each session has its own detail view.
Demo Flows: sessions per day, steps, visitor paths, answers to questions, priority-grid ratings, playlist plays, completion rate, and what visitors told the AI guide. Visitors who left an email are listed across flows.
Sales Rooms: an activity view for each room.
Datasets: who used each Dataset and when.
Known viewers: email gates and lead forms (6.7) tie sessions to named people, so usage can be read per prospect.
5.2 Through the MCP (recommended)
The recommended way to work with usage data is to ask the agent. The MCP reads the same analytics as the app, with the user's permissions, so there is no separate key or export to set up. Because the agent can also reach the CRM and call recordings, it can combine usage with deal context in one answer.
Operations: Product Tour analytics, Clone analytics and viewer engagement, Data Injection analytics, and Demo Flow analytics (overview, one flow, visits, one visit, identified visitors across flows, and AI-guide visitor insights). Find them with platform_api_search and an intent such as "analytics".
Example requests:
"Which prospects opened the leave-behind this week, and how far did each get?"
"Rank our tours by completion this quarter and flag any with a step where most viewers drop off."
"Summarize what visitors asked the AI guide in the security Demo Flow, and draft FAQ answers."
"For every open opportunity in the CRM, list who has viewed a Reprise demo in the last 30 days."
5.3 Data API
Accounts with API access, an Enterprise-plan feature (see the plans page in 7.1), can query usage data directly, for BI tools and data warehouses.
Endpoints:
Product Tour session activity: one row per viewer event
Product Tour session summary: one row per session
Product Tour metrics: engagement per tour or per link
Product Tour change feed: published tours and links that changed or were deleted, for keeping a copy in sync
Clone sessions: one row per viewer session
Clone session engagement: page views, clicks, form submits and active time per session
Clone session events: one row per viewer event; typed values are never included
Parameters: a time range and a row limit; some endpoints also group by tour or link, or filter by event type.
Access: named API keys are created in Settings. Keys are stored hashed, can be revoked, and are exchanged for short-lived access tokens. Results are always limited to the account's own data.
Try it: Settings includes a query playground for each endpoint.
5.4 Pushing data to other systems
Salesforce. Connect a production or sandbox org.
When a viewer identifies themselves on a tour link, Reprise matches them to an existing Lead or Contact by email, or creates one (Lead or Contact, as configured).
It logs a completed Task on the record for each view, with the tour, the link, and a link to the session timeline in Reprise. Session duration is added once the session ends.
For a link tied to an Opportunity, the Task is logged on the Opportunity, with its stage and the sales rep.
HubSpot and Marketo.
A link can use the account's own HubSpot or Marketo form as its lead-capture gate, so the lead lands in that system directly.
Each screen a viewer sees is reported to the account's HubSpot or Marketo tracking, alongside the rest of its web activity.
Google Analytics 4. Each screen view is reported to the account's GA4 property.
The page that embeds a tour. An embedded Product Tour (4.1) tells the host page when a session starts and when the screen changes, so the site's own analytics tag can record it.
Slack. A Sales Room's conversation with the prospect can be mirrored to the rep's Slack messages or to a channel.
Anything else, through the agent. An agent connected to both Reprise and another system can read usage from the MCP and write it wherever the user wants, such as a summary on a CRM record or a weekly report.
Part 6 — Security, identity and governance
For security reviewers. For the agent connection itself (OAuth, token lifetimes, untrusted-content marking), see 2.3 and 2.5.
6.1 Sign-in and SSO
SSO:
SAML 2.0 with any standards-based identity provider (e.g. Okta, Microsoft Entra ID), configured per account, on the Enterprise plan.
OAuth sign-in with Google and Microsoft.
An account can restrict which login methods its users may use, for example SSO only.
Two-step login for email/password sign-in:
Authenticator-app codes (TOTP), passkeys (WebAuthn) and single-use recovery codes.
An account admin can require it.
SSO logins take their second factor from the identity provider.
Enterprise:custom roles built from the permissions above.
Roles are assigned to users directly or through groups, including SCIM groups.
Licenses cap what a role can grant:
A Builder license can build and administer.
A Presenter license can only view, present, share links, activate Datasets and work in Sales Rooms and Flows. This holds whatever roles the user is given. Presenter licenses cost less than Builder licenses.
6.4 Access lists (ACLs)
On plans with access controls, each Product Tour, Clone and folder carries an access list:
Private flag: the item is hidden from everyone not on the list.
Default role for all users: Viewer, Editor or Publisher.
Per-user and per-group entries: one level each:
Owner: full control, including changing access and deleting
Publisher: edit and publish
Editor: edit
Viewer: preview and list
Folder access governs what a user sees in the library sidebar and lists. Presenter-licensed users can be granted at most Viewer access.
AI agents inherit all of this. An agent connected through the MCP acts as the signed-in user, with that user's roles, license and access lists. It cannot see or change anything the user couldn't.
6.5 Audit and monitoring
Governance audit log: an immutable log, readable in the product and through the MCP by users with "View audit log" (Admin and SecurityAdmin by default). It covers:
Users: created, updated, deleted, roles and groups changed, password set, two-step reset
Groups and roles: created, updated, deleted, members and permissions changed
SAML configuration: created, updated, deleted
Account: settings changed, roles and groups changed, MSA accepted
Assets: Product Tours and Clones created, captured, published, republished, exported, archived, deleted, backed up and restored. Access lists, folders and tags changed. Links created, updated and deleted. Demo Flows archived and restored
Account memory: changes
AI agent call log: every MCP tool call, reads and writes alike, plus in-app agent calls, is written to an append-only log.
It records tool, status, timing and argument names.
It is PII-free by design: argument values and results are never stored, and the actor is pseudonymized.
Reprise holds this log. Your user's Reprise rep can arrange access or an export for the account.
Not yet in the governance audit log: Dataset, Sales Room and Demo Flow edits. Dataset snapshots and the agent call log cover part of this.
Per-demo activity history: publishes, backups, restores, duplicates and editing sessions, down to individual screen and guide edits.
SCIM activity log: see 6.2.
6.6 Data protection and compliance
Tenant isolation: enforced at three layers:
The MCP service rejects responses or writes that cross accounts.
Requests carry the caller's account context.
Every backend query is scoped to the account.
Secrets at rest: integration credentials and authenticator secrets are encrypted, with key rotation supported. SCIM tokens and recovery codes are stored as hashes.
Sensitive data in Clones: scan, scrub and revert (3.2). Capture from a sanitized demo tenant wherever possible.
Account offboarding: the account's data is deleted.
No new AI sub-processors for the MCP: the agent runs under the customer's own agreement with its AI provider. Data the agent pulls from other tools goes to that provider under the customer's terms. Reprise's models don't receive it.
Certifications and compliance: SOC 2 Type II and ISO 27001:2022 for the company, plus GDPR compliance. Your user's Reprise rep can share the current reports and their scope.
6.7 Controls on shared demos
Published links can be protected with:
Expiry dates
A viewer password
Required email capture
Restriction to allowed email domains or specific addresses
An account-level IP allowlist (CIDR ranges)
Custom domains
Embed-only links, limited to listed domains (4.1)
Flows add room settings for who may open them. Archiving a Sales Room stops its links.
6.8 Agent governance
Usage limits per account: caps on MCP calls per session, calls per user per day, and characters returned per session.
From 80% of a cap, the agent is warned so it can tell the user.
At the cap, the call is refused with usage_limit_reached and, for the daily cap, a reset time.
AI spend settings and credits: these apply to Reprise-side AI features.
Approval gating: read/write tool separation and annotations let your MCP client require human approval for writes and destructive actions.
Listed tools mark deletes with destructiveHint. Through the gateway, writes and deletes both go through platform_api_write, so require approval on that tool to gate deletes.
ChatGPT Plus and Pro expose MCP tools read-only.
ChatGPT Business, Enterprise and Edu allow read/write, behind admin settings and per-call approval.
Scoped endpoints: each one limits an agent to one asset type.
Reprise extension (Chrome Web Store): https://chromewebstore.google.com/detail/reprise/pemgfdnmnnikondejlnfpimdnabfphdp
Reprise Builder: Cloning extension (Chrome Web Store): https://chromewebstore.google.com/detail/lnfdgbcchgafpkhdifedffopdacbncaj
Security and compliance: https://www.reprise.com/enterprise-scale-and-security
Plans and pricing: https://www.reprise.com/plans
7.2 Contact
Your user's Reprise account executive can answer pricing, security review and procurement questions, and can arrange a reference call with a customer in your user's industry.