MCP integration

Wire runs a hosted MCP server, the same way Supabase and HeyGen do. You connect your AI client to it once, add your key as a bearer header, and from then on the client can call Wire's tools: read your funnel, run the improve loop, set your experiment arms. Nothing runs from your repo, and there is no server to build. You get your key from your dashboard and point your client at one URL.

Also available: skills and a prompt

Wire ships Claude skills for the different parts of the app (integration, the question script, the learning loop), which explain and drive each part from inside your editor. No skill runner and no MCP? The kit ships an AGENTS.md and a copy-paste prompt that do the same job.

Connect your client

The server lives at https://wireai-mcp.fly.dev/mcp and speaks the HTTP transport. There is no login step and no config file on disk for this path. You authenticate on every request with an Authorization: Bearer <key> header, where the key is either your tenant wai_ key or the admin key. In Claude, one command adds it:

claude mcp add --transport http wireai https://wireai-mcp.fly.dev/mcp \
$
--header"Authorization: Bearer <key>"

Other clients connect the same server. In Claude Code, Cursor, Codex, or any MCP client, paste the URL https://wireai-mcp.fly.dev/mcp and the same Authorization: Bearer <key> header into its MCP settings. The server is stateless: it holds no secret, it just forwards your key to the Wire backend, which enforces scope.

Where your key comes from

Open your app in the dashboard and copy its key from the Set Up tab. That key is the bearer token above. There is no one-click connect button yet, so you copy the key and run the connect command once. Read the key from your environment, never commit it.

Your AI client

Claude, Claude Code, Cursor, Codex, any MCP client

Hosted MCP server

wireai-mcp.fly.dev/mcp over HTTP, stateless, stores no secret

Wire backend enforces scope

A wai_ key reaches read and loop tools. The admin key adds management and experiments.

Wire's tools respond

Your client calls them like any other MCP tool

Your key rides on every request as a bearer header. The backend reads it, enforces scope, and the MCP itself stores nothing.

Two scopes

Which key you connect with decides what the client can reach. The backend enforces this on every call, so a tenant key can never touch an admin-only tool.

Tenant

Connect with your wai_ key to get the read and loop tools: wireai_get_insights, wireai_submit_learning_report, wireai_mark_learning_applied, plus the no-auth guide and components tools. Hand a read-loop-only user just this key.

Admin / operator

The admin key reaches everything the tenant key does, plus app management (register, update, list) and the experiment tools that set your A/B/C/D arms. Reserve this key for whoever registers and configures apps.

What you can invoke

Once connected, the client calls Wire's tools like any other MCP tool. Most read. The tenant key runs the learning loop: pull a funnel brief, upload a learning report, flag it applied. The admin key adds app management and the four experiment tools, wireai_get_experiments plus the three that set your onboarding, review, and questionnaire arms, so you can move an experiment from your editor without opening the console.

Tool	Scope	Reads / writes
`wireai_get_integration_guide`	none	read (static recipe)
`wireai_list_components`	none	read (static vocabulary)
`wireai_get_insights`	tenant	read (funnel brief as Markdown)
`wireai_get_onboarding_config`	admin	read (live generation config)
`wireai_register_onboarding_app`	admin	write (create an app)
`wireai_list_onboarding_apps`	admin	read
`wireai_get_onboarding_app`	admin	read (raw record)
`wireai_update_onboarding_app`	admin	write (patch config, no release)
`wireai_get_onboarding_analytics`	admin	read (funnel JSON)
`wireai_submit_learning_report`	tenant	write (upload a learning report)
`wireai_list_learning_reports`	admin	read (all tenants' reports)
`wireai_mark_learning_applied`	tenant	write (flag a report applied)
`wireai_get_experiments`	admin	read (live A/B/C/D arms)
`wireai_set_onboarding_experiment`	admin	write (set the onboarding arm)
`wireai_set_review_experiment`	admin	write (set the review arm)
`wireai_set_questionnaire_experiment`	admin	write (set the questionnaire arm)

This table lists the tools that are stable to name. The server runs version 0.3.0 and returns its full, current tool list on connect, so treat what your client shows after connecting as the source of truth.

Skills for each part of the app

The MCP is not the only way in. Wire also ships Claude skills for the different parts of the app, each one explaining and driving its part: one for wiring the SDK into your app, one for designing the question script, one for running the learning loop off a week of real traffic. They live in your editor, so most of the work happens where you already code.

See the skills

The full set is on the skills page, with when each one fires and how to run it.

Troubleshooting

A tool returns unauthorized

The remote path reads your key on every request, so an unauthorized response means the Authorization: Bearer header is missing, malformed, or the key was rotated. Rotating a key invalidates it everywhere at once. Copy the current key from your dashboard and reconnect.

An admin tool refuses a tenant key

A tenant wai_ key can never reach an admin-only tool. The backend rejects it on every admin route. If you need app management or the experiment tools, reconnect with the admin key.

Insights come back empty

When the funnel has no data yet, wireai_get_insights returns a valid "no data yet" Markdown brief with an HTTP 200, not an error. That is expected before your first traffic. It passes straight through.

Next: Skills