The Metabind platform
Control what your agent can reach, run and show, in Claude, ChatGPT, every MCP host and your own apps. Every answer is validated before it renders, your keys stay server-side, and code runs sandboxed on the server and on the device.
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, in layers:
Your UI, on every screen.
Experience
Your components become Interactive tools, each with a JSON schema and a component allowlist. Convert the app you have, and start from the standard library in your brand while you do.
Your customers’ conversations appear here.
Show me something for my lounge
product_searchData Tool
Contour Lounge Chair$949Add to cartAdded ✓
Petal Bouclé Chair$1,190Add to cart
Woven Dusk Throw$119Add to cartInstall the Metabind CLI, then point Claude Code or Codex at your workspace. It converts your SwiftUI, Jetpack Compose or React components, or a Figma file, into BindJS, and wraps your REST or GraphQL endpoints as Data tools.
$ brew install metabindai/tap/metabindDescribe what you want in Metabind Studio and the Metabind Agent builds it with you: the components, the tools and the script your agent follows. Then refine it in the Playground.
Experience
One BindJS definition renders in Claude, ChatGPT and every MCP host, and natively in your iOS, Android and web apps. Same answer, same components, on every screen.
Your components render as React inside the host's sandboxed frame. Standards-compliant: SEP-1724, SEP-1865.
Real SwiftUI, with native gestures, animation, dynamic type and accessibility, at 60 FPS.
Real Jetpack Compose, with Material3 defaults and native scroll, at 60 FPS.
Same schema, same validation, same allowlist on every surface. The agent can't render on Android what you didn't approve on iOS.
Experience
The open component language your UI is written in. Declarative and SwiftUI-shaped: SwiftUI developers read it on sight, Jetpack Compose developers carry the mental model across, and React developers keep their component and props patterns.
const body = (props) => { const [added, setAdded] = useState(false) return VStack({ spacing: 12, alignment: "leading" }, [ Image({ url: props.image, contentMode: "fill" }) .frame({ height: 180 }) .cornerRadius(14), Text(props.name).font("headline"), Text(props.price) .foregroundStyle(Color("secondary")), Button(added ? "Added ✓" : "Add to cart", () => setAdded(true)) ]).padding(16)}
One component definition renders natively on three platforms. Not React on mobile, not a translation layer: a component language designed end to end with its runtimes.
Component logic runs in the BindJS sandbox and reaches only the hosts you allow, so new components ship without an app release.
PropertyString through PropertyComponent, with 40+ chainable modifiers across layout, styling, gestures and animation. Complete reference in the docs.
The runtime, its sandbox, all three renderers and every client SDK are Apache 2.0. Clone it, read it, fork it. Nothing that ships inside your app is closed.
Experience
Build components visually or in code, configure your tools and write your agent's script, with a live native preview, an inspector, branching and version history alongside. Then open the Playground and talk to the agent you're building, with your tools running live, or preview it on your phone through an App Clip on iOS.
Experience
Drop photos, video and 3D models into Metabind Studio. Every file comes out agent-ready: described, encoded for every platform (HLS video, USDZ and GLB 3D), indexed for search by meaning and served from the edge, where your agent finds it through search_assets. No vector database, no embedding pipeline, no player library.
One publish. Every channel.
Distribution
Publish compiles your tool definitions into a standards-compliant MCP server (SEP-1724, SEP-1865), and Metabind hosts, validates, versions and scales it. No transport code, no host conformance work, no deploy pipeline.
One MCP endpoint, beside your agent's other servers, on any model or framework.
Every project has a draft server for work in progress and a production server that moves only when you publish.
Publishing is a metadata flip, not a deployment. The next request routes to the new version, with nothing to drain.
Distribution
The Assistant SDK puts the same agent in your iOS, Android and web apps: Swift Package on iOS, Maven on Android. Run a full assistant on the Agent Proxy, or render the answers of the agent you already have.
import SwiftUIimport MetabindAI struct AssistantScreen: View { let assistant: MetabindAssistant var body: some View { MetabindAssistantView(assistant: assistant) .navigationTitle("Assistant") }}
import ai.metabind.ai.MetabindAssistantimport ai.metabind.ai.MetabindAssistantView @Composablefun AssistantScreen() { val assistant = remember { MetabindAssistant(apiKey = apiKey, orgId = orgId, projectId = projectId) } MetabindAssistantView(assistant = assistant)}
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.
Answers render inline as real SwiftUI on iOS, Jetpack Compose on Android and React on the web, with your app's typography, colors and accessibility settings.
The Agent Proxy runs your script on every turn, on Anthropic, OpenAI or Gemini, and calls the MCP endpoint for every tool. Keys stay server-side and never ship in your client.
Already have one? The SDK's renderers draw its answers natively, with the same components and the same validation.
Distribution
Two complete apps with the Assistant SDK inside, on iOS and Android. Clone one, point it at your APIs, and run the whole agent inside your own app.
An interior design assistant for a home furnishings catalog. Product carousels, side-by-side comparisons, color palettes and generated room inspiration all come back as rendered components, so the conversation stays visual instead of collapsing into a wall of text.
View and Clone
A personal finance app driven entirely by a Metabind project. Its tools render into a native tab-and-sheet structure: the same MCP server an agent would talk to, presented as an app.
View and Clone
Distribution
Serverless, auto-scaling, multi-tenant infrastructure on AWS.
Tool-call traffic scales horizontally: no provisioning, no capacity planning, launch spikes absorbed.
Component packages are content-addressed and pushed to CDN edges, so your components render at the user's location with no round trip and no cold start.
Every tenant runs isolated, with its secrets encrypted per tenant.
Photos, video and 3D served from a global CDN with automatic format negotiation, resolution serving and caching.
Control what your agent can reach, run and show. Once it's live, your agent answers in your UI in Claude, ChatGPT and your own apps: your cards, your carousels, your Add to cart.
Governance
Your components only, validated before they render, versioned and reversible. Every response is checked against its schema and component allowlist before anything renders: a product-search tool renders product cards, not an admin table. Violations come back as typed errors that name exactly what broke, so invalid data never reaches the user.
Savile · shelf
show_viewGovernance
Every component ships in an immutable, versioned package, and published tools render from a pinned version. Stage the next one beside production, then promote it or roll it back on the next request, in every channel at once.
Work in progress, served only to your test clients.
Draft serverThe next version runs beside production against real tool calls.
Beside productionA metadata flip. The next request routes to the new version.
Zero downtimeBad render? One switch back, and every channel follows on the next request.
Governance
Decide who edits, who publishes and who approves, at the organization and the project level. Developers own the components, designers own the design system and product owns the tools.
Roles at the organization and project level: who edits, who publishes, who approves. On Team and Enterprise.
Sign in with your identity provider, configured once for the whole organization. On Enterprise.
By email invite with role assignment, revoked cleanly and auditable.
Security
Answers are composed at runtime, long after your app shipped, so no code review or app release ever sees them. The checks travel with every answer: the model never sees your keys and never writes your code.
Data tools call your REST and GraphQL APIs with an API key, OAuth 2.0 or custom headers. Secrets are encrypted per tenant and injected at runtime, never in component code or the client.
Every handler runs in its own V8 isolate: 60 seconds and 128MB, restricted outbound HTTP, no filesystem, per-tenant isolation.
In your apps, component logic runs in the BindJS sandbox and reaches only the hosts you allow, in open source code you can read. In Claude and ChatGPT, it renders inside the host's sandboxed frame.
Per-organization rate limits and concurrency caps, configurable on Enterprise.
Evaluation
Every tool call in every host, traced and ready to evaluate: timestamp, input, output, caller and render outcome, across Claude, ChatGPT, VS Code and your own apps.
Which tools run, for whom and in which host, across every channel. On the Developer plan and up.
An audit trail you can export and query, kept for 30 days on Team and 1 year on Enterprise.
When a tool misbehaves, read the exact input, the exact output and the exact validation path.
With the Agent Proxy in your own apps, every conversation is traced to your own Langfuse project: each model turn, every tool call and its result. On paid plans.