From idea to your team in minutes — not weeks.

Business teams build AI apps in the browser. Teammates request access Okta-style. Deployed in your environment — your data, your audit trail.

Request a demo See architecture

InsightStudio marketplace — apps grouped by category with search, filter chips, and per-app access state

The gap Studio closes

Every AI app demo lives in the same valley of death: it works for the person who built it, but reaching everyone else's hands takes a sprint of engineering effort no one budgeted for.

The usual path · 2–6 weeks

Demo → engineering ticket → eventually-shipped

Someone shows a working prompt in a 1:1 — "this could save the team hours."
File a ticket. Wait for engineering capacity.
Engineer writes a wrapper script (Python? Flask? Lambda?).
Add auth: who can run this? How do they sign in?
Security review of the new endpoint.
Package + deploy to internal infra.
Ops sets up monitoring + audit logging.
Admin manually provisions access for the first 5 users.
Original demo author has to re-explain what it does to every new user.

The InsightStudio path · same day

Demo → publish → marketplace → access → run

Business user opens Studio's prompt-to-app builder.
Describes the app in plain English → Studio generates the bundle.
Tweaks the inputs/outputs visually if needed; runs a test.
Clicks Publish — admin gets a review notification.
Admin approves; app surfaces in the team's marketplace.
Teammates discover it, click Request access, admin approves (Okta-style).
Audit log + governance kick in automatically — no extra wiring.
Author moves on to the next idea instead of writing docs.

Pillar 1 · App creation

Business users build apps. Not engineers.

The in-browser builder takes a plain-English description of what the app should do and produces a working bundle — form fields, agent workflow, output panels, all the wiring. The user iterates visually. No code, no packaging, no deploy pipeline.

Prompt-to-app generator — describe what you want, get a working app
Visual widget editor — drag-and-drop form fields and output panels
Live test runs — try the app with real inputs before publishing
Version + rollback — every publish is a new immutable version
No-code path covers ~80% of cases — power users can still drop into YAML

Studio builder · prompt-to-app

                                ▶ describe your app

                                "Pull every broker submission from the SharePoint inbox last week,

                                  extract policy number + insured name + premium, classify by

                                  line of business, and email a weekly digest to underwriting."

Studio generated: 3 inputs · 4 workflow steps · 5 output panels · manifest with sharepoint + email creds

Run test with last week's actual data — preview the digest before publishing

Publish → app surfaces in the underwriting team's marketplace

The access-request flow

Step 1

Discover

Browse the marketplace by team or tag

Step 2

Request

One-click access request to admin

Step 3

Approve

Admin grants — or denies — with audit trail

Step 4

Run

Open the app, fill the form, live results

Group-based grants ("Claims team can run X") auto-apply to new members — no per-user provisioning when someone joins or moves teams.

Pillar 2 · Access

Discover. Request. Run. Like Okta for AI apps.

Every published app shows up in your team's marketplace. Users browse the catalog, see what's available, and self-request access. Admins approve or deny with one click. No tickets, no Slack DMs, no "can someone add me to that thing?"

Self-serve discovery — search, filter by team, sort by recency
Request access — click a button, admin gets notified
Group-based grants — "Claims team can run X" auto-applies to new members
Per-app approvers — different reviewers per app, mirror your org
Audit-logged — every access grant + every run captured

Three things, one platform

Studio collapses what's usually three separate efforts — app creation, access management, and operations — into one place your team already trusts.

1 · Rapid creation

Prompt-to-app generator + visual editor. Business users build working apps in minutes — without code, without an engineering handoff.

2 · Self-serve access

Marketplace + Okta-style access requests. Users find the app, ask for access, admins approve. Teammates onboard in minutes, not days.

3 · Enterprise control

Deploys in your VPC. SSO, audit log, per-org governance, capability-matched worker fleet. Secrets never leave your network. SOC 2-ready.

Built for every role in the loop

Each role gets the surface they need — and never has to use the others.

Business builder

Describes the app, iterates visually, publishes. No code skills required. The person who knows the problem builds the solution.

Teammate / runner

Opens marketplace, requests access if needed, fills a form, sees results. No install, no setup, no .env.

Admin / approver

Reviews new apps before they surface. Approves access requests. Manages groups and per-app grants. Pulls audit reports.

IT / DevOps

Helm or docker-compose install. Wires SSO, S3, DB, model endpoints. Scales the worker fleet. Standard ops tooling all the way down.

The engine inside

Studio runs on InsightWorker

Every Studio run is executed by an InsightWorker agent. Power users (or engineers) can also author apps locally with the InsightWorker CLI and publish directly to Studio — same bundle format, same outcome. The marketplace just makes the result reachable by everyone else.

Worker boxes — laptops, VMs, on-prem servers — run insightworker --worker to join your Studio fleet. Outbound-only, secrets stay on the box.

insightworker.com → How they work together

Two paths to the marketplace

In the browser — business builders use Studio's prompt-to-app + visual editor. No install needed.

From the CLI — engineers and power users edit YAML locally, then iw app publish.

Both produce identical bundles. Both surface in the same marketplace. Both honor the same governance.

Speed without giving up control

The reason most "low-code internal tool" platforms don't make it through enterprise procurement: they fast-track creation but ignore governance. Studio doesn't.

SSO + RBAC

Okta, Azure AD, Google Workspace. Group sync. Per-app grants by user, team, or org role. Group-based grants auto-apply to new members.

App approval workflow

No app surfaces in the marketplace without a designated reviewer's sign-off. Different reviewers per team if you want.

Full audit log

Every run, every step, every tool call. Who built it, who ran it, what model, what tokens. SIEM webhook export. SOC 2 / GDPR / HIPAA ready.

Model governance

Provider lockdown, region pinning, per-org token quotas. Disable tools by name. Capability-matched worker routing.

Your data, your network

Studio runs in your VPC. S3 in your account. Postgres in your DB cluster. No telemetry, no data egress.

Versioned + rollback

Every published app version is immutable. Rollback to any prior version with one click. The audit log captures which version ran each time.

Stop losing AI prototypes to the engineering backlog.

The next time a business user demos something that works — they should be able to ship it to their team that same afternoon. InsightStudio makes that possible, in your environment, on your governance, with your audit trail.