Built on the open MCP standard
The platform your agent runs on.
You author the components, the tools, and the script. Metabind runs the rest: an agent proxy that drives multi-step tool calls, native rendering on three platforms, hosted MCP servers, and governance enforced on every render. One publish reaches Claude, ChatGPT, every MCP host, and your own app.
Try the Demo
Start Free
The architecture.
An agent is orchestration over governed tools. Packaged and published, that collection of tools is an MCP App, defined by the open Model Context Protocol (SEP-1724) and its MCP Apps extension (SEP-1865). Metabind is the platform that runs it. Six concepts:
MCP App Docs
The agent proxy.
Metabind runs the reasoning loop: multi-step tool calls, planned and executed against the system prompt you author. This is the agent. You configure it; you don't operate it.
The system prompt.
Authored in Metabind. Greet like this. Ask X before Y. Cross-sell here. Never leave the catalog. The proxy holds to it on every turn.
The MCP App Server.
Generated from your tools, hosted and scaled by Metabind. It speaks the protocol to every host and validates every response before it renders. You configure the tools; you never deploy the server.
Interactive Tools.
Your UI, as tools. Each declares a JSON schema and a component allowlist. The agent calls it with structured data; Metabind validates and renders: React in the host, SwiftUI and Jetpack Compose in your app.
Data Tools.
Your APIs, as tools. Any REST or GraphQL endpoint, proxied with runtime-injected secrets and sandboxed execution. Data Tools fetch; Interactive Tools render.
The native SDKs.
Swift, Kotlin, and React. The Assistant SDK runs the same MCP App inside your own product and renders Interactive Tools as real SwiftUI and Jetpack Compose. One publish, two surfaces: every MCP host, and your app.
Build it.
Convert what you already have, or author from scratch: components, tools, content, and media, in code or in the Studio.
BindJS. One language, three renderers.
The component language Metabind compiles to native. Declarative and SwiftUI-shaped: SwiftUI developers read it on sight, Jetpack Compose developers transfer the mental model, React developers keep their component patterns and props architecture. Apache 2.0, runtime and all three renderers. Fork it.
BindJS Docs
View on GitHub
Built for cross-platform native.
One component definition renders natively on three platforms. Not React on mobile. Not a translation layer. A purpose-built component language, designed end to end with the runtimes.
Familiar by design.
Declarative syntax, a similar layout model, similar composability patterns. SwiftUI and Jetpack Compose developers find the mental model transfers directly. React developers work at the component-and-props layer.
Full property and modifier system.
PropertyString through PropertyComponent, with 40+ chainable modifiers across layout, styling, gestures, and animation. Complete reference in the docs.
Open source.
The runtime and all three renderers are Apache 2.0, along with every client SDK. Clone it, read it, fork it. Nothing that ships inside your app is closed.
Interactive Tools. Native on every surface.
Every Interactive Tool compiles to React, SwiftUI, and Jetpack Compose from a single BindJS definition.
Interactive Tools Docs
React in the MCP host.
Interactive Tools render as React in Claude, ChatGPT, VS Code, and every MCP Apps host. Sandboxed iframe, standards-compliant: SEP-1724, SEP-1865.
SwiftUI on iOS.
Real SwiftUI. Native gestures, native animation, App Store compliant, 60 FPS.
Jetpack Compose on Android.
Real Jetpack Compose. Material3 defaults, native scroll, 60 FPS.
One definition, identical everywhere.
Same schema, same validation, same allowlist on every surface. The agent can't render on Android what you didn't approve on iOS.
MCP App Studio. Build it, then talk to it.
Build components visually or in code, configure your tools, and author the agent's script. The editor keeps a live native preview alongside, with an inspector, save states, branching, and version history.
MCP App Studio Docs
Playground.
Talk to the agent you're building, with your tools running live. Change the script or a component, ask again; nothing deploys in between.
Test on real devices.
Any component, content, or full MCP App gets a preview link. iOS opens it as an App Clip, real SwiftUI on the phone in your hand, no install. Android opens the preview app. Web opens the browser.
Sample apps.
Clone one, point it at your APIs, publish.
Draft by default.
The Studio previews against your draft endpoint. Production doesn't move until you publish.
Data Tools.
Point at your endpoint. Configure auth: API key, OAuth 2.0, or custom headers. Ship.
Data Tools Docs
Secrets stay server-side.
Stored encrypted, injected at runtime. Never in component code, never in the client.
Isolation by default.
Every handler runs in its own V8 sandbox: 60-second execution limit, 128MB, restricted outbound HTTP, no filesystem.
Typed both directions.
Schemas declared up front. The server validates inputs from the agent and outputs back to it. Integration errors surface at the boundary, immediately.
Media, built in.
Drop photos, video, and 3D models into the Studio. Every file comes out agent-ready.
Assets Docs
Semantic search, auto-registered.
Every upload is indexed, and a search tool exposes the library to the agent. No vector database, no embedding pipeline.
Video as HLS.
Multi-resolution encoding, CDN delivery, native playback on all three platforms. No player library.
3D, native.
USDZ on iOS, GLB on Android and web. Rotate, zoom, interact.
Ship it.
One button between draft and the world.
Hosted MCP servers.
Publish generates a standards-compliant MCP server and runs it. No transport code, no host conformance work, no deploy pipeline. Every project gets two endpoints.
Publishing Docs
Draft.
Serves everything: published, modified, in progress. Point a test client at it and iterate.
Production.
Serves only what you published. It's where Claude, ChatGPT, and your Assistant SDK deployment connect.
Zero-downtime publishes.
Publishing is a metadata flip, not a deployment. The next request routes to the new version. Nothing to drain.
Assistant SDK.
The same MCP App, running as a governed agent inside your own iOS, Android, or web app. Swift Package on iOS, Maven on Android.
iOS SDK Docs
Android SDK Docs
The MCP Apps protocol, handled.
Tool calls, streaming responses, and schema validation on every render. The SDK implements the spec and keeps up with it, so your app wires up a view instead of a protocol.
A chat UI you can ship or replace.
MetabindAssistantView is a complete conversational surface: message rendering, streaming, and conversation state. Drop it in as is, or take the streaming client and the BindJS renderer and build your own.
Native UI, in the conversation.
Interactive Tools render inline as real SwiftUI on iOS, Jetpack Compose on Android, and React on web, inheriting your app's typography, colors, and accessibility settings.
Your key, server-side.
Anthropic, OpenAI, or Gemini, configured once in the agent proxy. The key stays on the server and never ships in your client, and every call through the proxy lands in your tool-call stats and Langfuse traces.
Run it.
What production looks like after the publish.
Governed on every render.
Every tool response is validated against its schema before anything renders.
Governance Docs
Schema validation.
Every tool response, every render. Invalid data is rejected with a typed error and never reaches the user.
Component allowlists.
Allowlists bound what can appear: a product-search tool renders product cards, not an admin table.
Typed errors, not silent failures.
Violations name exactly what broke. Fix it once; it stays fixed.
Versioned. Reversible.
Every component ships in an immutable, semantically versioned package, and published tools render from a pinned version, not whatever's newest.
Versioning Docs
Stage beside production.
Stage the next version beside production, test it against real tool calls, promote when ready.
One button back.
Bad render in production? One button back, and every tool referencing the package switches immediately.
Every tool call. Logged.
Timestamp, input, output, caller, render outcome: every invocation, across every host. Claude, ChatGPT, VS Code, your own app.
Usage analytics.
Which tools run most, which users run them, which hosts render what. Daily active MCP Apps, inline renders, Assistant SDK MAU.
Audit trail.
The audit trail is exportable and queryable. Langfuse integration on all paid plans: evaluate and tune the agent on real conversations.
Debug faster.
When a tool misbehaves, you read the exact input, the exact output, and the exact validation path. No guessing.
Built for teams.
Developers own the component system. Designers own the design system. PMs configure tools, content editors assemble from governed components, marketing uploads media. Everyone ships without waiting on engineering.
Team Management Docs
RBAC.
At the organization and project level: who edits, who publishes, who approves.
SSO.
Through your identity provider, configured once.
Membership.
By email invite with role assignment, revoked cleanly, auditable.
Scale is the default.
Serverless, auto-scaling, multi-tenant infrastructure on AWS.
Auto-scaling.
Tool-call traffic scales horizontally: no provisioning, no capacity planning, launch spikes absorbed.
Edge-cached packages.
Component packages are content-addressed and pushed to CDN edges, so Interactive Tools render at the user's location with no round trip and no cold start.
Tenant isolation.
The same per-handler V8 sandboxing as Data Tools, with secrets encrypted per tenant.
Global asset delivery.
Photos, video, and 3D served from a global CDN with automatic format negotiation, resolution serving, and caching.
Rate limits and quotas.
Per-organization concurrency caps and rate limits protect your upstream APIs from runaway calls. Configurable at Enterprise.
Built on the open MCP standard
The platform your agent runs on.
You author the components, the tools, and the script. Metabind runs the rest: an agent proxy that drives multi-step tool calls, native rendering on three platforms, hosted MCP servers, and governance enforced on every render. One publish reaches Claude, ChatGPT, every MCP host, and your own app.
Try the Demo
Start Free
The architecture.
An agent is orchestration over governed tools. Packaged and published, that collection of tools is an MCP App, defined by the open Model Context Protocol (SEP-1724) and its MCP Apps extension (SEP-1865). Metabind is the platform that runs it. Six concepts:
MCP App Docs
The agent proxy.
Metabind runs the reasoning loop: multi-step tool calls, planned and executed against the system prompt you author. This is the agent. You configure it; you don't operate it.
The system prompt.
Authored in Metabind. Greet like this. Ask X before Y. Cross-sell here. Never leave the catalog. The proxy holds to it on every turn.
The MCP App Server.
Generated from your tools, hosted and scaled by Metabind. It speaks the protocol to every host and validates every response before it renders. You configure the tools; you never deploy the server.
Interactive Tools.
Your UI, as tools. Each declares a JSON schema and a component allowlist. The agent calls it with structured data; Metabind validates and renders: React in the host, SwiftUI and Jetpack Compose in your app.
Data Tools.
Your APIs, as tools. Any REST or GraphQL endpoint, proxied with runtime-injected secrets and sandboxed execution. Data Tools fetch; Interactive Tools render.
The native SDKs.
Swift, Kotlin, and React. The Assistant SDK runs the same MCP App inside your own product and renders Interactive Tools as real SwiftUI and Jetpack Compose. One publish, two surfaces: every MCP host, and your app.
Build it.
Convert what you already have, or author from scratch: components, tools, content, and media, in code or in the Studio.
BindJS. One language, three renderers.
The component language Metabind compiles to native. Declarative and SwiftUI-shaped: SwiftUI developers read it on sight, Jetpack Compose developers transfer the mental model, React developers keep their component patterns and props architecture. Apache 2.0, runtime and all three renderers. Fork it.
BindJS Docs
View on GitHub
Built for cross-platform native.
One component definition renders natively on three platforms. Not React on mobile. Not a translation layer. A purpose-built component language, designed end to end with the runtimes.
Familiar by design.
Declarative syntax, a similar layout model, similar composability patterns. SwiftUI and Jetpack Compose developers find the mental model transfers directly. React developers work at the component-and-props layer.
Full property and modifier system.
PropertyString through PropertyComponent, with 40+ chainable modifiers across layout, styling, gestures, and animation. Complete reference in the docs.
Open source.
The runtime and all three renderers are Apache 2.0, along with every client SDK. Clone it, read it, fork it. Nothing that ships inside your app is closed.
Interactive Tools. Native on every surface.
Every Interactive Tool compiles to React, SwiftUI, and Jetpack Compose from a single BindJS definition.
Interactive Tools Docs
React in the MCP host.
Interactive Tools render as React in Claude, ChatGPT, VS Code, and every MCP Apps host. Sandboxed iframe, standards-compliant: SEP-1724, SEP-1865.
SwiftUI on iOS.
Real SwiftUI. Native gestures, native animation, App Store compliant, 60 FPS.
Jetpack Compose on Android.
Real Jetpack Compose. Material3 defaults, native scroll, 60 FPS.
One definition, identical everywhere.
Same schema, same validation, same allowlist on every surface. The agent can't render on Android what you didn't approve on iOS.
MCP App Studio. Build it, then talk to it.
Build components visually or in code, configure your tools, and author the agent's script. The editor keeps a live native preview alongside, with an inspector, save states, branching, and version history.
MCP App Studio Docs
Playground.
Talk to the agent you're building, with your tools running live. Change the script or a component, ask again; nothing deploys in between.
Test on real devices.
Any component, content, or full MCP App gets a preview link. iOS opens it as an App Clip, real SwiftUI on the phone in your hand, no install. Android opens the preview app. Web opens the browser.
Sample apps.
Clone one, point it at your APIs, publish.
Draft by default.
The Studio previews against your draft endpoint. Production doesn't move until you publish.
Data Tools.
Point at your endpoint. Configure auth: API key, OAuth 2.0, or custom headers. Ship.
Data Tools Docs
Secrets stay server-side.
Stored encrypted, injected at runtime. Never in component code, never in the client.
Isolation by default.
Every handler runs in its own V8 sandbox: 60-second execution limit, 128MB, restricted outbound HTTP, no filesystem.
Typed both directions.
Schemas declared up front. The server validates inputs from the agent and outputs back to it. Integration errors surface at the boundary, immediately.
Media, built in.
Drop photos, video, and 3D models into the Studio. Every file comes out agent-ready.
Assets Docs
Semantic search, auto-registered.
Every upload is indexed, and a search tool exposes the library to the agent. No vector database, no embedding pipeline.
Video as HLS.
Multi-resolution encoding, CDN delivery, native playback on all three platforms. No player library.
3D, native.
USDZ on iOS, GLB on Android and web. Rotate, zoom, interact.
Ship it.
One button between draft and the world.
Hosted MCP servers.
Publish generates a standards-compliant MCP server and runs it. No transport code, no host conformance work, no deploy pipeline. Every project gets two endpoints.
Publishing Docs
Draft.
Serves everything: published, modified, in progress. Point a test client at it and iterate.
Production.
Serves only what you published. It's where Claude, ChatGPT, and your Assistant SDK deployment connect.
Zero-downtime publishes.
Publishing is a metadata flip, not a deployment. The next request routes to the new version. Nothing to drain.
Assistant SDK.
The same MCP App, running as a governed agent inside your own iOS, Android, or web app. Swift Package on iOS, Maven on Android.
iOS SDK Docs
Android SDK Docs
The MCP Apps protocol, handled.
Tool calls, streaming responses, and schema validation on every render. The SDK implements the spec and keeps up with it, so your app wires up a view instead of a protocol.
A chat UI you can ship or replace.
MetabindAssistantView is a complete conversational surface: message rendering, streaming, and conversation state. Drop it in as is, or take the streaming client and the BindJS renderer and build your own.
Native UI, in the conversation.
Interactive Tools render inline as real SwiftUI on iOS, Jetpack Compose on Android, and React on web, inheriting your app's typography, colors, and accessibility settings.
Your key, server-side.
Anthropic, OpenAI, or Gemini, configured once in the agent proxy. The key stays on the server and never ships in your client, and every call through the proxy lands in your tool-call stats and Langfuse traces.
Run it.
What production looks like after the publish.
Governed on every render.
Every tool response is validated against its schema before anything renders.
Governance Docs
Schema validation.
Every tool response, every render. Invalid data is rejected with a typed error and never reaches the user.
Component allowlists.
Allowlists bound what can appear: a product-search tool renders product cards, not an admin table.
Typed errors, not silent failures.
Violations name exactly what broke. Fix it once; it stays fixed.
Versioned. Reversible.
Every component ships in an immutable, semantically versioned package, and published tools render from a pinned version, not whatever's newest.
Versioning Docs
Stage beside production.
Stage the next version beside production, test it against real tool calls, promote when ready.
One button back.
Bad render in production? One button back, and every tool referencing the package switches immediately.
Every tool call. Logged.
Timestamp, input, output, caller, render outcome: every invocation, across every host. Claude, ChatGPT, VS Code, your own app.
Usage analytics.
Which tools run most, which users run them, which hosts render what. Daily active MCP Apps, inline renders, Assistant SDK MAU.
Audit trail.
The audit trail is exportable and queryable. Langfuse integration on all paid plans: evaluate and tune the agent on real conversations.
Debug faster.
When a tool misbehaves, you read the exact input, the exact output, and the exact validation path. No guessing.
Built for teams.
Developers own the component system. Designers own the design system. PMs configure tools, content editors assemble from governed components, marketing uploads media. Everyone ships without waiting on engineering.
Team Management Docs
RBAC.
At the organization and project level: who edits, who publishes, who approves.
SSO.
Through your identity provider, configured once.
Membership.
By email invite with role assignment, revoked cleanly, auditable.
Scale is the default.
Serverless, auto-scaling, multi-tenant infrastructure on AWS.
Auto-scaling.
Tool-call traffic scales horizontally: no provisioning, no capacity planning, launch spikes absorbed.
Edge-cached packages.
Component packages are content-addressed and pushed to CDN edges, so Interactive Tools render at the user's location with no round trip and no cold start.
Tenant isolation.
The same per-handler V8 sandboxing as Data Tools, with secrets encrypted per tenant.
Global asset delivery.
Photos, video, and 3D served from a global CDN with automatic format negotiation, resolution serving, and caching.
Rate limits and quotas.
Per-organization concurrency caps and rate limits protect your upstream APIs from runaway calls. Configurable at Enterprise.
Built on the open MCP standard
The platform your agent runs on.
You author the components, the tools, and the script. Metabind runs the rest: an agent proxy that drives multi-step tool calls, native rendering on three platforms, hosted MCP servers, and governance enforced on every render. One publish reaches Claude, ChatGPT, every MCP host, and your own app.
Try the Demo
Start Free
The architecture.
An agent is orchestration over governed tools. Packaged and published, that collection of tools is an MCP App, defined by the open Model Context Protocol (SEP-1724) and its MCP Apps extension (SEP-1865). Metabind is the platform that runs it. Six concepts:
MCP App Docs
The agent proxy.
Metabind runs the reasoning loop: multi-step tool calls, planned and executed against the system prompt you author. This is the agent. You configure it; you don't operate it.
The system prompt.
Authored in Metabind. Greet like this. Ask X before Y. Cross-sell here. Never leave the catalog. The proxy holds to it on every turn.
The MCP App Server.
Generated from your tools, hosted and scaled by Metabind. It speaks the protocol to every host and validates every response before it renders. You configure the tools; you never deploy the server.
Interactive Tools.
Your UI, as tools. Each declares a JSON schema and a component allowlist. The agent calls it with structured data; Metabind validates and renders: React in the host, SwiftUI and Jetpack Compose in your app.
Data Tools.
Your APIs, as tools. Any REST or GraphQL endpoint, proxied with runtime-injected secrets and sandboxed execution. Data Tools fetch; Interactive Tools render.
The native SDKs.
Swift, Kotlin, and React. The Assistant SDK runs the same MCP App inside your own product and renders Interactive Tools as real SwiftUI and Jetpack Compose. One publish, two surfaces: every MCP host, and your app.
Build it.
Convert what you already have, or author from scratch: components, tools, content, and media, in code or in the Studio.
BindJS. One language, three renderers.
The component language Metabind compiles to native. Declarative and SwiftUI-shaped: SwiftUI developers read it on sight, Jetpack Compose developers transfer the mental model, React developers keep their component patterns and props architecture. Apache 2.0, runtime and all three renderers. Fork it.
BindJS Docs
View on GitHub
Built for cross-platform native.
One component definition renders natively on three platforms. Not React on mobile. Not a translation layer. A purpose-built component language, designed end to end with the runtimes.
Familiar by design.
Declarative syntax, a similar layout model, similar composability patterns. SwiftUI and Jetpack Compose developers find the mental model transfers directly. React developers work at the component-and-props layer.
Full property and modifier system.
PropertyString through PropertyComponent, with 40+ chainable modifiers across layout, styling, gestures, and animation. Complete reference in the docs.
Open source.
The runtime and all three renderers are Apache 2.0, along with every client SDK. Clone it, read it, fork it. Nothing that ships inside your app is closed.
Interactive Tools. Native on every surface.
Every Interactive Tool compiles to React, SwiftUI, and Jetpack Compose from a single BindJS definition.
Interactive Tools Docs
React in the MCP host.
Interactive Tools render as React in Claude, ChatGPT, VS Code, and every MCP Apps host. Sandboxed iframe, standards-compliant: SEP-1724, SEP-1865.
SwiftUI on iOS.
Real SwiftUI. Native gestures, native animation, App Store compliant, 60 FPS.
Jetpack Compose on Android.
Real Jetpack Compose. Material3 defaults, native scroll, 60 FPS.
One definition, identical everywhere.
Same schema, same validation, same allowlist on every surface. The agent can't render on Android what you didn't approve on iOS.
MCP App Studio. Build it, then talk to it.
Build components visually or in code, configure your tools, and author the agent's script. The editor keeps a live native preview alongside, with an inspector, save states, branching, and version history.
MCP App Studio Docs
Playground.
Talk to the agent you're building, with your tools running live. Change the script or a component, ask again; nothing deploys in between.
Test on real devices.
Any component, content, or full MCP App gets a preview link. iOS opens it as an App Clip, real SwiftUI on the phone in your hand, no install. Android opens the preview app. Web opens the browser.
Sample apps.
Clone one, point it at your APIs, publish.
Draft by default.
The Studio previews against your draft endpoint. Production doesn't move until you publish.
Data Tools.
Point at your endpoint. Configure auth: API key, OAuth 2.0, or custom headers. Ship.
Data Tools Docs
Secrets stay server-side.
Stored encrypted, injected at runtime. Never in component code, never in the client.
Isolation by default.
Every handler runs in its own V8 sandbox: 60-second execution limit, 128MB, restricted outbound HTTP, no filesystem.
Typed both directions.
Schemas declared up front. The server validates inputs from the agent and outputs back to it. Integration errors surface at the boundary, immediately.
Media, built in.
Drop photos, video, and 3D models into the Studio. Every file comes out agent-ready.
Assets Docs
Semantic search, auto-registered.
Every upload is indexed, and a search tool exposes the library to the agent. No vector database, no embedding pipeline.
Video as HLS.
Multi-resolution encoding, CDN delivery, native playback on all three platforms. No player library.
3D, native.
USDZ on iOS, GLB on Android and web. Rotate, zoom, interact.
Ship it.
One button between draft and the world.
Hosted MCP servers.
Publish generates a standards-compliant MCP server and runs it. No transport code, no host conformance work, no deploy pipeline. Every project gets two endpoints.
Publishing Docs
Draft.
Serves everything: published, modified, in progress. Point a test client at it and iterate.
Production.
Serves only what you published. It's where Claude, ChatGPT, and your Assistant SDK deployment connect.
Zero-downtime publishes.
Publishing is a metadata flip, not a deployment. The next request routes to the new version. Nothing to drain.
Assistant SDK.
The same MCP App, running as a governed agent inside your own iOS, Android, or web app. Swift Package on iOS, Maven on Android.
iOS SDK Docs
Android SDK Docs
The MCP Apps protocol, handled.
Tool calls, streaming responses, and schema validation on every render. The SDK implements the spec and keeps up with it, so your app wires up a view instead of a protocol.
A chat UI you can ship or replace.
MetabindAssistantView is a complete conversational surface: message rendering, streaming, and conversation state. Drop it in as is, or take the streaming client and the BindJS renderer and build your own.
Native UI, in the conversation.
Interactive Tools render inline as real SwiftUI on iOS, Jetpack Compose on Android, and React on web, inheriting your app's typography, colors, and accessibility settings.
Your key, server-side.
Anthropic, OpenAI, or Gemini, configured once in the agent proxy. The key stays on the server and never ships in your client, and every call through the proxy lands in your tool-call stats and Langfuse traces.
Run it.
What production looks like after the publish.
Governed on every render.
Every tool response is validated against its schema before anything renders.
Governance Docs
Schema validation.
Every tool response, every render. Invalid data is rejected with a typed error and never reaches the user.
Component allowlists.
Allowlists bound what can appear: a product-search tool renders product cards, not an admin table.
Typed errors, not silent failures.
Violations name exactly what broke. Fix it once; it stays fixed.
Versioned. Reversible.
Every component ships in an immutable, semantically versioned package, and published tools render from a pinned version, not whatever's newest.
Versioning Docs
Stage beside production.
Stage the next version beside production, test it against real tool calls, promote when ready.
One button back.
Bad render in production? One button back, and every tool referencing the package switches immediately.
Every tool call. Logged.
Timestamp, input, output, caller, render outcome: every invocation, across every host. Claude, ChatGPT, VS Code, your own app.
Usage analytics.
Which tools run most, which users run them, which hosts render what. Daily active MCP Apps, inline renders, Assistant SDK MAU.
Audit trail.
The audit trail is exportable and queryable. Langfuse integration on all paid plans: evaluate and tune the agent on real conversations.
Debug faster.
When a tool misbehaves, you read the exact input, the exact output, and the exact validation path. No guessing.
Built for teams.
Developers own the component system. Designers own the design system. PMs configure tools, content editors assemble from governed components, marketing uploads media. Everyone ships without waiting on engineering.
Team Management Docs
RBAC.
At the organization and project level: who edits, who publishes, who approves.
SSO.
Through your identity provider, configured once.
Membership.
By email invite with role assignment, revoked cleanly, auditable.
Scale is the default.
Serverless, auto-scaling, multi-tenant infrastructure on AWS.
Auto-scaling.
Tool-call traffic scales horizontally: no provisioning, no capacity planning, launch spikes absorbed.
Edge-cached packages.
Component packages are content-addressed and pushed to CDN edges, so Interactive Tools render at the user's location with no round trip and no cold start.
Tenant isolation.
The same per-handler V8 sandboxing as Data Tools, with secrets encrypted per tenant.
Global asset delivery.
Photos, video, and 3D served from a global CDN with automatic format negotiation, resolution serving, and caching.
Rate limits and quotas.
Per-organization concurrency caps and rate limits protect your upstream APIs from runaway calls. Configurable at Enterprise.