# Custom Apps

Custom Apps are interactive tools you build with AI inside Insulin.

---

## What Are Custom Apps?

A Custom App is a reusable interface, dashboard, form, or workflow tool generated and edited with the Insulin app builder. Use a Custom App when a workflow needs more structure than a chat answer, such as a revenue dashboard, a deal review tool, a co-sell tracker, or an internal operations screen.

Custom Apps are different from built-in Insulin apps such as Chat, Jobs, Marketplace, Knowledge Base, Inbox, Settings, Files, Browser, or Git. Built-in apps are part of the Insulin workspace. Custom Apps are apps your team creates, runs, edits, and shares.

![The Custom Apps workspace — Org Apps and My Apps in the sidebar, "New App" to start the AI builder, and a live preview pane rendering a saved app](images/05-insulin-custom-apps.png)

## When to Use a Custom App

Use a Custom App when you want to:

- Turn a repeated marketplace workflow into a reusable interface
- Build a dashboard or report from connected systems
- Create a form-like tool for sales, operations, or partner workflows
- Combine AI-generated UI with approved integration actions
- Share an internal app with teammates without building a separate product

For one-off questions, use [Chat](./2.chat.md). For repeatable background work, use [Jobs](./6.jobs.md). For packaged expertise, use [Agents](./3.agents.md) and [Marketplace](./7.marketplace.md).

## Build Dashboards with AI

Custom Apps are the recommended way to build dashboards and reports in Insulin.

As we continue to expand AI-powered analytics, the legacy Analytics experience is being deprecated. As of July 2026, no removal date is committed — existing Analytics dashboards keep working until one is announced. Instead of relying on fixed dashboards, users can create dashboards tailored to their own marketplace workflows using AI.

You can create a dashboard by simply describing what you need in natural language. For example:

- "Show my top customers by marketplace revenue over the last 90 days."
- "List overdue marketplace payments."
- "Build an AWS Marketplace revenue dashboard."
- "Track offer acceptance rates and pending private offers."

The AI builder generates an interactive dashboard that you can continue refining through conversation or by editing the generated app.

### Migration from Analytics

If you currently use the legacy Analytics dashboards, we'll help you migrate them to AI Custom Apps. Our team can help recreate your existing dashboards as AI Apps while preserving the reports and workflows your team relies on. If you have any questions about migration or need assistance, please contact your Customer Success Manager.

## Build Flow

Custom Apps use an AI builder loop:

1. Open **Custom Apps**
2. Create a new app or open an existing app in the builder
3. Describe what you want the app to do
4. Choose a template or start from a prompt
5. Select the app scope and allowed integrations
6. Review the generated app in the live preview
7. Keep iterating in the builder chat until the preview works as expected
8. Save the app

The builder keeps a chat history for the app-editing session. You can ask for changes, inspect the preview, and save when the generated app is ready.

### Chat mode vs Edit mode

The builder's message box has two modes, toggled next to the composer:

- **Edit** (default) — your message modifies the app and produces a new live-preview build. Use this to make changes.
- **Chat** — the builder answers in prose without touching the app. Use this to ask questions, plan an approach, or sanity-check an idea before you commit to a change.

When you're in Chat mode and the builder proposes a concrete change, the reply shows an **Implement this** button. Clicking it switches to Edit mode and sends the suggestion as your next edit — a one-click path from discussion to implementation.

### Visual Edit (element inspector)

Once a preview is rendered, a **Visual Edit** button appears next to the mode toggle. Turn it on, click an element in the live preview, and your next message is scoped to just that element — for example, "make this chart taller" or "change this label." Press **Esc** to clear the selection. This is the precise way to refine a specific part of a generated app instead of describing the whole screen.

### Choose the AI model

The builder includes a model picker (the sparkle button near the composer) so you can choose which model generates the app. Models are grouped by provider — **Anthropic**, **OpenAI**, and **Google** — and which models appear depends on the app's **ownership**:

- **Organization apps** offer two key sources per model: **Suger's key** (Suger's hosted access, always available) and **Your key** (your organization's own connected provider key — BYOK). BYOK rows for providers you haven't connected are greyed out; connect that provider first to enable them.
- **Personal apps** show only **Your key** rows for the providers you've connected — the **Suger's key** (Suger-hosted) rows are not offered. Connect a provider to add its models.

The model you pick is pinned on the app, so saved apps keep building with the same model.

## Templates

Custom Apps can start from first-party templates. Templates provide vetted multi-file source for common analytics and marketplace workflows, then you can customize them in the builder.

Four starter templates are available in the **New App** panel:

| Template | What it builds |
|----------|----------------|
| **Revenue Analytics** | A marketplace revenue dashboard — cash-flow and unpaid KPIs, revenue trend, revenue by product, partner, and currency, and top buyers. |
| **Offer Metrics** | An offer-book performance dashboard that combines the revenue trend and top-buyer widgets with offer counts, pending acceptances, and creation failures. |
| **Private Offer Analytics** | An offer-pipeline dashboard organized into Overview, Actions, and Logs tabs, with total and accepted-offer KPIs and the acceptance-rate trend. |
| **Co-Sell Analytics** | A co-sell pipeline dashboard — referrals by status, partner, and owner, creation trend, use-case and lifecycle-stage breakdowns, and an opportunity-by-region table. |

Templates are useful when you want a working starting point before asking AI to tailor the app to your organization. Leave the template unselected to start from a blank app and build it entirely from a prompt.

![Creating a new Custom App — start from a template or a blank app, name it, add a description, and choose Personal (only you) or Organization ownership](images/10-insulin-create-app.png)

## Multi-File Source

Custom Apps are stored as a source-file map rather than a single text blob. The entry file is `App.tsx`, and supporting files can hold components, helpers, and data-shaping code.

This lets the builder create more maintainable apps:

- UI code can be split into focused files
- Imported Custom Apps can be tracked as dependencies
- The saved app can be recompiled when dependencies change
- Compile conflicts can be handled before the app is saved

An app can hold up to **20 source files**, and each file can be up to **200 KB**.

### Importing another app

You can reuse another Custom App inside the one you're building. The builder has an **Imported apps** panel above the chat: click **Import app**, pick any app you have access to (grouped into your apps and org apps), and it's added as a dependency. Each imported row has a **Swap** action to replace it with a different app and a remove (**✕**) action to drop it. When you save, Insulin recompiles the app so it picks up the current version of anything it imports.

## Preview, Compile, and Safety Checks

The live preview is a working app preview, not a static mock. Before code is rendered or saved, Insulin compiles it and runs safety checks.

The compile and safety process can report:

| Result | Meaning |
|--------|---------|
| **Compiled code** | The app built successfully and can be previewed or saved. |
| **Safety errors** | The app contains blocked patterns and must be revised. |
| **Mock data warnings** | The app appears to rely on hardcoded or placeholder data. |
| **Compile error** | The generated source did not compile and needs another edit. |

The builder can also run a visual review. Visual review uses the rendered app preview, screenshots, runtime logs, network activity, and user prompt to decide whether the output matches the request or needs another edit.

## Integrations and Sensitivity Tiers

Custom Apps can be allowed to use connected systems. Each configured integration includes sensitivity tiers:

| Tier | Use |
|------|-----|
| **read** | Read data from the connected system. |
| **write** | Create or update data in the connected system. |
| **outbound** | Send data or trigger outbound actions. |

Only selected integrations and selected sensitivity tiers are available to the app. This keeps an app's runtime access narrower than the full set of tools your user or organization has connected.

:::info
Changing integrations on an organization-level Custom App requires organization administrator access in addition to the required app role.
:::

## Ownership and Sharing

Custom Apps can be user-level or organization-level.

| Ownership | Behavior |
|-----------|----------|
| **User** | Private to the creator (labeled **Personal** in the builder). Use this for personal tools or drafts. |
| **Organization** | Shareable with teammates. Use this for team workflows and shared dashboards. |

### Sharing an app

Only organization-level apps can be shared, and the two ways to share combine:

- **Share with the entire organization** — turn on **Share with entire organization** and pick a default role for every member. Org-wide sharing offers **Editor**, **User**, or **Viewer**.
- **Share with specific users** — select a user and assign a role. Individual sharing offers **Admin**, **Editor**, **User**, or **Viewer**.

A member's effective access is the higher of the two, so you can share an app org-wide as **Viewer** and grant **Editor** or **Admin** to the few people who maintain it.

| Role | Run & interact | Edit & save | Manage sharing | Delete |
|------|:---:|:---:|:---:|:---:|
| **Owner** | Yes | Yes | Yes | Yes |
| **Admin** | Yes | Yes | Yes | No |
| **Editor** | Yes | Yes | No | No |
| **User** | Yes | No | No | No |
| **Viewer** | View only | No | No | No |

The **Owner** is the app's creator and is the only role that can delete the app.

When you open an app shared with you, its run panel shows an owner-and-role banner — even before the app has been built — and anyone below **Editor** (a **User** or **Viewer**) sees it **read-only**. See [Working with a Shared Resource](./1.getting-started.md#working-with-a-shared-resource).

:::info
Transferring ownership of a Custom App is currently **API-only** (org administrator to org administrator). There is no in-product control for it — the sharing dialog does not surface a transfer option for apps today.
:::

![Sharing an app — the org-wide toggle with a default role, plus per-user shares for granting higher permissions](images/11-insulin-share-app.png)

### Finding and managing your apps

Saved Custom Apps appear in the Custom Apps sidebar, split into **Org Apps** (organization-level apps shared with you) and **My Apps** (your personal apps). A search box filters both lists by name or description.

Right-click any app in the sidebar for a context menu. The available actions depend on your role:

- **Edit App** — open the app in the builder
- **Add to Desktop** — pin the app to the Insulin desktop as an icon so you can launch it directly
- **Share App** — open the Share dialog (organization apps only)
- **Delete App** — permanently remove the app

<!-- screenshot needed: Custom Apps sidebar showing Org Apps / My Apps groups, the search box, and the right-click context menu (Edit App / Add to Desktop / Share App / Delete App) (app-only) -->

## Running a Saved App

When a Custom App is saved, Insulin stores the compiled bundle and the normalized integration configuration. Running the app uses the saved compiled code and enforces the configured integration access at runtime.

If an app has no compiled code yet, open it in the builder, generate or fix the app, and save it before using it as a working tool.

## How Custom Apps Fit With Insulin

Custom Apps work best alongside the rest of Insulin:

- Use [Agents](./3.agents.md) to define the expertise behind a workflow
- Use [Marketplace](./7.marketplace.md) to install reusable agents or skills before building
- Use [Jobs](./6.jobs.md) for scheduled or event-triggered runs
- Use [Channels](./5.channels.md) when teammates need to discuss app output with agents
- Use [knowledge bases](./4.knowledge-base.md) and connected systems to ground the app in your organization's data