LiveApps
A LiveApp is a governed, interactive mini-app — a self-contained HTML and JavaScript front end — that opens in the Canvas pane beside your PebbleChat conversation. Think of a cyber-incident console, a data-entry form, a small dashboard: a real, clickable app surface that lives next to the chat instead of inside it.
LiveApps can come bundled with plugins, be created by you (with help from an authoring skill), or be generated by the agent right in the conversation and saved to the catalogue for reuse.
What makes a LiveApp different from a random web widget is the word governed. Every LiveApp runs in a locked-down sandbox:
- Sandboxed iframe with an opaque origin — no access to PebbleAI cookies, storage, or the surrounding page
- No external network — a strict Content Security Policy blocks every outbound call
- No credentials — API keys and secrets never enter the app; only governed tool results do
- Capability allow-list — the only thing an app can do beyond its own UI is call the Pebble skills on its declared allow-list
- Your permissions still apply — every call is additionally checked against your own entitlements, so an app can never do anything you couldn’t do yourself
Opening a LiveApp
There are four ways to open a LiveApp — the first two don’t involve the AI at all:
| From | How | What happens |
|---|---|---|
| The @ menu | Type @ in the composer (or click the Add context button) and pick the LiveApps category | The app opens in Canvas immediately — no mention is inserted and no chat message is sent |
| A shortcut tile | Click a LiveApp shortcut in the shortcuts tray | The app opens deterministically — no AI round-trip, no chat message |
| Asking in plain language | Type something like “open the cyber console” | Pebble knows which LiveApps are available to you and opens the one you named |
| The agent itself | The agent can open a LiveApp mid-conversation as part of its work | The app appears in Canvas alongside its response |
While an app loads you’ll briefly see a loading screen with the app’s title and the message Connecting to app surface… before the app takes over the pane.

The @ menu and the plain-language launcher only list LiveApps that are enabled for you. If someone shares a new app with you and it doesn’t appear, enable it first from the catalogue — see Browsing and enabling below.
Pinning a LiveApp as a shortcut
To put a LiveApp one click away permanently:
- Hover the shortcuts tray on the composer and click the + button (Add shortcut)
- In the Add a Shortcut dialog, under What should this shortcut link to?, choose In-app item
- Set Item type to LiveApp (the other options are Flow and Predefined shortcut)
- Pick your app in the Select a LiveApp picker and save
Choosing Predefined shortcut instead pins a ready-made shortcut from the catalogue — the tile copies that shortcut’s own icon, subtitle and name. See Shortcuts for the full tour of trays, tiles, and customisation.

Browsing and enabling LiveApps
The catalogue lives at Settings → Capabilities (the page header reads User Capabilities). Its tab strip includes a LiveApps tab and a Shortcuts tab alongside your other capabilities.
The LiveApps tab shows each app with these columns:
| Column | What it tells you |
|---|---|
| LiveApp | The app’s name |
| Description | What it does |
| Scope | The level the app belongs to — User, Workspace, Org, or Platform. Plugin-bundled apps appear as their own rows, typically at Platform or Org scope |
| Status | Whether it’s enabled for you |
| Deploy to all users | Admin-only — pushes the app to everyone at once |
| Actions | Open, share, and manage |
The Shortcuts tab adds a Target column showing what each catalogue shortcut opens — for example a LiveApp, a prompt, or an external link.
To discover apps you don’t have yet, use the Add Capability browse dialog on the Capabilities page and enable what you need. Enabling a plugin also surfaces any LiveApps and Shortcuts it bundles as their own rows on these tabs.
Creating a LiveApp
Asking the agent to build one
The fastest route is to just describe the app you want in chat. The agent can generate a LiveApp — including React-based apps, transpiled right in the browser — and open it in Canvas immediately. Agent-generated apps render under a warning banner:
Agent-generated — review this Live App before trusting it with real data.
If you like the result, click Save this Live App. On success you’ll see “Saved to your Live Apps. Review it before sharing or trusting it with real data.” and the header changes to Saved to your Live Apps.
After saving, review works like this:
- Users with the Create LiveApps permission see an Approve button on the review banner. Approving clears the banner for everyone (“Live App approved.”).
- Users without it see “(awaiting approval from someone with create rights)” appended to the banner instead.
Approving an agent-generated app only clears the review banner — it does not widen what the app can call. The app’s grant is always its allow-list intersected with each user’s own permissions.
Two more things worth knowing about agent-generated apps:
- If the app isn’t connected to any skill (its allow-list is empty), it shows an info banner explaining that it stores data locally only — nothing is saved or sent anywhere.
- If the app crashes at runtime, the pane shows “This Live App hit a runtime error” with the error message rather than a blank frame.
Creating one by hand
Users with the Create LiveApps permission see a Create LiveApp button on the Capabilities → LiveApps tab. The dialog explains the model up front: a LiveApp is a self-contained HTML mini-app that runs sandboxed in the chat canvas and can call your allowed skills. Use the LiveApp authoring skill in a chat to help generate one, then paste the finished HTML here.
| Field | Notes |
|---|---|
| Name | Required |
| Description | Shown in the catalogue |
| Save to | Personal (only visible to you) or Workspace (available for admins to enable across your workspace — org or platform admins only) |
| Capability allow-list | The skills this app may call. Only skills selected here can be invoked by the app — wildcards are not permitted |
| HTML content | A self-contained HTML document — inline scripts and styles only, data-URI images only, no external network calls (the CSP blocks them) |
Sharing and publishing
Open a LiveApp’s catalogue detail (or use the per-row Share action on the LiveApps or Shortcuts tab) and you get two sharing modes:
- Publish for discovery — makes the app discoverable in the catalogue for everyone in a scope. The buttons are Publish to Workspace, Publish to Project and Publish to Organization; each turns into a “Published to…” confirmation once done.
- Share with individuals — a people picker (you can select people or paste a user ID) plus a Share button for handing the app to specific colleagues.
Publishing buttons are permission-gated: without the matching publish permission for a scope, that button is disabled with a tooltip explaining why. Plugin-bundled and platform-managed apps never show publish or share controls at all — they’re governed through enablement and deployment instead.
Publishing makes an app discoverable — colleagues may still need to enable it from the catalogue before it appears in their @ menu. Discovery and enablement are deliberately separate steps.
Permissions and governance
What you’ll see as a user
Because every skill call is checked server-side, permission problems surface as clear in-app messages rather than silent failures:
| Situation | What happens |
|---|---|
| You lack the Launch Live Apps permission | Launching is blocked with a permission error, and any skill call from an app is denied with “You do not have permission to use LiveApps.” |
| The app calls a skill outside its allow-list | The app receives (and typically displays) “Skill … is not in this LiveApp’s capability allow-list.” |
| The app calls a skill you personally aren’t entitled to | The call is denied — an app can never call anything you couldn’t call yourself |
| The app has no allow-listed skills at all | An info banner explains the app stores data locally only |
How admins govern LiveApps
Admins control LiveApps at three levels, from broadest to narrowest:
| Level | Where | Effect |
|---|---|---|
| Platform default | Admin → Platform → Settings → Canvas Surfaces tab → LiveApp switch | The platform-wide default for every organisation. Also requires the platform Canvas master switch (Feature Flags tab → Canvas group → Canvas) to be on |
| Organisation kill switch | Admin → Organisation → Settings → Configuration → Chat Settings tab → Canvas surfaces section → LiveApp toggle | Turning this off blocks every user in the organisation from opening any LiveApp, even ones enabled individually |
| Per-app enablement | Admin → Organisation → Settings → Capabilities (page titled Enabled Capability Instances) → LiveApps tab | Toggle individual apps — including blocking a single plugin-bundled app org-wide without disabling its parent plugin — and use Deploy to all users to push an app to everyone |
All Canvas surfaces default to on.

Access is then refined per user through RBAC permissions:
| Permission | What it gates |
|---|---|
| Launch Live Apps | Opening or using any LiveApp at all |
| Create LiveApps | Creating apps via the dialog — and approving agent-generated ones |
| Share LiveApps with Individuals | The people-picker share |
| Publish LiveApps to Workspace / Project / Organization | Each publish scope separately |
By default the standard organisation user role can launch, create, and share with individuals; the organisation admin role additionally holds all three publish permissions. See Admin → Capabilities for how capability governance fits together across the platform.
Activity and audit
Skill executions triggered from LiveApp buttons are recorded and surfaced in PebbleObserve → Usage under the Capability Activity panel, alongside skills and connected-tool calls, with a Type filter to narrow to LiveApp-sourced runs. Org admins see the same activity in the observability surfaces, attributed by user, organisation and session. See PebbleObserve for the wider observability picture.
LiveApps and Canvas
LiveApps are one of several Canvas surfaces, and they’re easy to confuse with the Chat App surface — both put an “app” beside your conversation. The distinction:
| Surface | What it is |
|---|---|
| Chat App | Generated declarative apps — dashboards, forms — rendered inline in chat. Display-oriented, produced on the fly |
| LiveApp | Sandboxed runnable mini-apps (plugin-provided, user-created, or agent-generated) that call governed skills and integrations. Catalogued, shareable, and governed |
Each surface has its own admin toggle in the Canvas surfaces settings, so an organisation can allow one without the other.
Limits and caveats
- Not on mobile yet. LiveApps haven’t shipped in the PebbleAI mobile app — today the mobile app opens app-type shortcuts in your device browser instead. Mobile support is in design.
- Shortcut tiles aren’t permission-filtered. You may see a LiveApp shortcut tile even without the Launch Live Apps permission — the permission error appears when you click it.
- Pinned tiles snapshot the catalogue shortcut. A pinned predefined shortcut copies the catalogue entry’s icon, subtitle and target at pin time; if an admin later retargets the catalogue shortcut, existing pinned tiles don’t update.
- The in-chat copy of a saved agent-generated app keeps showing the generated version for that conversation. The saved catalogue copy is what opens when you launch the app later.
- Enablement is separate from discovery. A freshly published or shared app may need enabling from the Capabilities catalogue before it appears in your @ menu.
Related
- Canvas — the pane LiveApps open in, and its other surfaces
- Shortcuts — trays, tiles, and pinning LiveApps for one-click launch
- @Mentions & Tools — the @ menu where the LiveApps category lives
- Skills — what LiveApps call through their capability allow-list
- User Settings → Capabilities — your personal capability view
- Admin → Capabilities — governance and deployment at scale
- Mobile — the PebbleAI mobile app (LiveApps not yet supported there)