OpenUI Cloud
OpenUI Cloud by Thesys generates interactive user interfaces and manages conversations and artifacts through OpenAI-compatible APIs.
Verdict
Common use cases
- Prototype landing pages from wireframe sketches
- Generate dashboard mockups for client reviews
- Build reusable form components for developers
- Iterate button styles across design system
- Mock data visualizations before backend work
Integration
- Vendor
- OpenUI Cloud
- Category
- other
- Auth
- API_KEY
- Tools
- 8
- Composio slug
openui
Tools
- Create Conversation
Create a managed OpenUI conversation that can receive persisted turns from Generate UI.
- Delete Conversationdestructive
Permanently delete one managed OpenUI conversation by ID.
- Generate UI
Generate an OpenUI response from text or structured Responses API input. Supports standalone generation, stored-response chaining, managed conversations, Cloud-native tools, and caller-owned function tools; function calls returned by the mo
- Get Artifact
Retrieve one persisted OpenUI artifact, including its complete renderable content.
- List Artifacts
List persisted OpenUI artifacts, optionally filtering by name or artifact kinds, one cursor-controlled page at a time.
- List Conversation Items
Read one cursor-controlled page of persisted messages and function-call items from a managed OpenUI conversation.
- List Conversations
List managed OpenUI conversations visible to the connected organization, one cursor-controlled page at a time.
- Rename Conversation
Change the title of an existing managed OpenUI conversation.
Setup
Setup guide
- 11. In Switchy, open your workspace settings and navigate to the Integrations tab. 2. Click 'Add MCP Integration' and select OpenUI Cloud from the directory. 3. Log in to your OpenUI Cloud account, navigate to API settings, and generate a new API key with artifact read/write and conversation management permissions. 4. Paste the key into Switchy's configuration modal and click 'Connect'. 5. Switchy will verify the key and confirm the connection. 6. Open any Project, type '@OpenUI Cloud generate a signup form with email validation' in the chat, and send. 7. The MCP will return a renderable artifact; click the preview link to confirm the component loaded. 8. To iterate, continue the conversation by referencing the artifact ID in follow-up prompts.
What teammates see: by default, memories from OpenUI Cloud are scoped to the Project (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Projects have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
Signup Form Prototype
@OpenUI Cloud generate a signup form with fields for email, password, and password confirmation. Include inline validation and a submit button styled with rounded corners.
Dashboard Card Grid
@OpenUI Cloud create a three-column grid of metric cards showing revenue, active users, and conversion rate. Each card should display a large number, a label, and a small trend indicator.
Iterate Button Styles
@OpenUI Cloud take artifact ID abc123 and change the primary button color to teal, increase padding by 4 pixels, and add a subtle shadow on hover.
Data Table Component
@OpenUI Cloud generate a sortable data table with columns for name, email, status, and actions. Include a search input above the table and pagination controls below.
List Saved Artifacts
@OpenUI Cloud list all artifacts created in the last seven days, filtered to show only form and button components.
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@OpenUI Cloud list all artifacts created in the last week and show me the three most recently updated ones
Found 47 artifacts created in the past 7 days. The three most recent are: (1) 'Dashboard Prototype v3' (React component, updated 2 hours ago), (2) 'Onboarding Flow Wireframe' (SVG diagram, updated 5 hours ago), and (3) 'API Response Schema' (JSON artifact, updated yesterday). Each artifact includes its full renderable content and metadata. Would you like me to retrieve the complete content of any of these?
This example shows the MCP's artifact-browsing capability across an organization's stored UI generations. Requires API key with read access to the OpenUI Cloud workspace. Pagination applies if your team has hundreds of artifacts—this example assumes a manageable result set.
@OpenUI Cloud create a new conversation called 'Mobile Nav Redesign' and generate a first UI draft showing a collapsible sidebar with icon-only mode
Created conversation 'Mobile Nav Redesign' (ID: conv_8x4k2m). Generated initial UI artifact showing a React component with collapsible sidebar: expands to show labels on hover, collapses to icon-only on mobile breakpoints. The artifact is now persisted in your workspace and linked to this conversation. You can continue refining this design by referencing the conversation ID in follow-up prompts.
Demonstrates the write path: spinning up a managed conversation and generating a stored artifact in one step. The MCP persists both the conversation thread and the UI output, so your team can iterate without losing context. Side-effect: creates durable records in your OpenUI Cloud account.
@OpenUI Cloud pull the last 10 messages from conversation 'Dashboard Prototype v3', summarize the design decisions, and generate a final polished version
Retrieved 10 conversation items spanning 3 days of iteration. Key decisions: switched from grid layout to flexbox for responsive behavior, added dark-mode toggle per user feedback, consolidated three separate charts into a tabbed interface. Generated final artifact incorporating all refinements—includes responsive breakpoints, accessibility labels, and the requested dark-mode CSS variables. Artifact saved as 'Dashboard Prototype v3 Final'.
This synthesis example shows how the MCP bridges conversation history with fresh UI generation, letting the AI distill design evolution into a polished output. Requires conversation ID from a prior session. Useful when a thread has grown long and you want to collapse decisions into one deliverable.
Use-case deep-dives
When you need throwaway UI mockups without designer bottleneck
A 6-person SaaS team runs weekly customer interviews and needs to test three onboarding flow variants before the next sprint. The PM writes a prompt describing each flow, Generate UI returns a working prototype in seconds, and the team shares artifact links in Slack for async feedback. This MCP wins when speed matters more than pixel-perfect design—you're validating logic and copy, not shipping production code. The managed conversation feature keeps iteration history clean across rounds of tweaks. If your team already has a design system or needs accessibility compliance out of the gate, skip this and stick with Figma. But for early-stage validation where you'd otherwise sketch on a whiteboard, OpenUI Cloud turns those sketches into clickable demos your customers can actually use.
Building internal tools when engineering bandwidth is zero
A 3-person support team at a B2B startup needs a searchable FAQ interface for their Notion docs, but engineering won't prioritize it for two quarters. The support lead uses Generate UI to create a simple search-and-filter view, stores it as an artifact, and drops the link in the team chat. Updates happen by re-generating with tweaked prompts—no deploy pipeline, no staging environment. This works when the tool is internal-only and the team tolerates rough edges. The 8-tool scope here is narrow: you're creating UI, not integrating with your CRM or ticket system. If you need the FAQ to pull live data from Zendesk or trigger workflows, you'll hit the wall fast. For static or lightly-dynamic internal UIs where 'good enough in 10 minutes' beats 'perfect in 10 weeks,' this is the call.
When your pitch needs a live chart and you're not a frontend dev
A solo founder is prepping a Series A deck and wants an interactive revenue-growth chart to embed in the appendix. Spreadsheet screenshots look stale; hiring a contractor for one chart is overkill. Generate UI takes a CSV paste and a two-sentence prompt, returns a working D3-style visualization, and the founder grabs the artifact URL to link from the deck. This scenario works because it's a one-off, the data is small, and interactivity is a nice-to-have, not a requirement. If you're building a dashboard that updates daily or needs to handle sensitive financial data with audit trails, this MCP isn't the answer—you need a real BI tool. But for founder-mode moments where you need something better than a static PNG and you have zero frontend chops, OpenUI Cloud closes the gap without burning a weekend on tutorials.
Frequently asked
What does the OpenUI Cloud MCP do in Switchy?
It lets your team generate, store, and manage UI components through OpenUI's API without leaving Switchy. You can create conversations that persist UI generation history, retrieve artifacts with their full renderable content, and chain responses together. Think of it as embedding OpenUI's component-generation engine directly into your workspace so designers and engineers share the same artifact library.
Do I need an OpenUI Cloud account to connect this MCP?
Yes. The MCP uses API key authentication, so you need an active OpenUI Cloud account and a valid API key. Whoever connects it in Switchy must have permission to generate keys in your OpenUI organization. The key grants access to all eight tools, including conversation management and artifact retrieval, so treat it like you would any production credential.
Can this MCP edit or delete UI artifacts after they're generated?
It can delete entire conversations but not individual artifacts. You can retrieve artifacts to inspect their content, list them by name or type, and rename conversations. If you need to modify an artifact's code or design, you'll generate a new version through the Generate UI tool. The MCP treats artifacts as immutable once created, which keeps your version history clean.
How is this different from using OpenUI's web dashboard?
The MCP brings generation and artifact management into your team's chat context. Instead of switching tabs to create a conversation or fetch an artifact, your AI assistant handles it inline. You lose OpenUI's visual editor and preview pane, but you gain the ability to script multi-step workflows—like generating three variants, storing them in a conversation, then pulling the best one into your codebase—all from Switchy.
Who on the team should connect the OpenUI Cloud MCP?
Whoever owns your OpenUI API keys and understands which artifacts the team needs access to. Usually a frontend lead or design-systems engineer. Once connected, anyone in the Switchy workspace can trigger generation or list artifacts, so make sure your OpenUI organization's permissions match your team's trust model. The MCP doesn't enforce per-user scopes beyond what the API key allows.