Parlane

Make your app Parlane-ready

There is no SDK to install. Your backend serves a manifest and JSON documents; Parlane renders them natively. The fastest way in is to hand the whole contract to the coding agent you already use — everything on this page exists so that an agent, pointed here, can finish the job without you copying anything else around.

The prompt

Paste this into Claude Code, Cursor, or any coding agent with access to your backend's repo. It is the frozen contract in prompt form — the identifiers in it (/.well-known/parlane.json, parlane://) are protocol-locked and won't change under you.

paste into your coding agent
Make my app Parlane-ready.

Parlane is a universal native mobile client. It renders my backend natively — chat,
voice, dashboards, push — from plain JSON I serve. There is no SDK. I implement a tiny
contract; any of the following it can already do (MCP) it reuses.

Implement chat unless I explicitly tell you not to. Chat is the core surface: voice rides
on it with no extra server work (speech runs on-device), and a connected app without chat
feels broken on first open. Wire /chat to whatever conversational or agent capability my
backend has; if it truly has none, ask me before omitting it, and then leave the chat
surface undeclared in the manifest so the client hides those tabs.

Do this:
1. Serve an app manifest at /.well-known/parlane.json (or an MCP resource
   "parlane://manifest"). Declare only the surfaces I actually support. All fields are
   optional. Validate it against spec/manifest.schema.json.
   Ask me about the look: accent, colors, dark/light — declare a theme in the manifest to
   skin my app's screens.

2. If I don't already speak MCP, add the REST fallback:
   - POST /chat {conversation_id, message, attachments?} -> Server-Sent Events with these
     event types: `delta` {text}, `tool` {tool,status,label?}, `done` {conversation_id,
     message_id?}, `error` {code,message}. End with exactly one `done` or `error`.
   - GET /ui/{dashboard_id} -> a UI document (spec/ui-document.schema.json): a tree from the
     17-type catalog {stack, card, text, metric, chart, table, list, image, button, input,
     toggle, slider, select, progress, badge, divider, map}. version:1, single root, max
     depth 12, max 500 nodes. Full-replace only — no patch format.
   - POST /action {action_id, tool, params, dashboard_id?} -> {ui} (a full replacement UI
     document) or {ack:true}. Interactive components carry an action envelope
     {tool, params?, confirm?, refresh:"self"|"none"|<dashboardId>}; inputs bind values by a
     `bind` name that I merge into params.

3. Require Authorization: Bearer <token> on every request. Optionally print a connect QR
   encoding parlane://connect?url=...&token=...

4. (Optional) For push, open an outbound WebSocket to the relay and send payloads matching
   spec/push.schema.json.

Constraints: dashboards are declarative data, never code. Keep all user-visible copy in the
JSON I serve. Follow the schemas in spec/ exactly and test against spec/examples/.

The prompt references spec/ files by repo-relative path. If your agent is working in your own repo, give it the hosted copies below — or point it at /llms-full.txt, which inlines the entire integration kit in one fetch.

With Claude Code, or any MCP client

The demo agent also hosts a developer-tools MCP server: the integration guide, this prompt, every schema, and a validator for each document type, exposed as callable tools (get_schema, validate_manifest, validate_ui_document, …). Add it and your coding agent can pull the contract and check its own work as it goes, instead of you ferrying files:

claude mcp add --transport http parlane-dev https://bmwey9kxk2.us-east-1.awsapprunner.com/mcp

Any MCP client works the same way — streamable HTTP, no auth, read-only. This is tooling for while you build; in production your backend talks to Parlane over its own MCP server (the manifest becomes the resource parlane://manifest, actions become tool calls) or the REST fallback from the prompt above.

The schemas

The JSON Schemas (draft 2020-12) are the authoritative contract — when any prose and a schema disagree, the schema wins. They are hosted here at stable URLs, so an agent in any repo can fetch and validate against them:

Readable companions: the manifest reference and the REST contract. Agent-facing index: /llms.txt.

Test against the live demo agent

A hosted reference server implements the REST contract end-to-end — chat over SSE, three dashboards, and the action loop. Use it to see valid documents before you write your own, or to diff your server's output against a known-good implementation:

fetch a known-good manifest
curl https://bmwey9kxk2.us-east-1.awsapprunner.com/.well-known/parlane.json

Fetch /ui/bridge the same way for a full UI document, or open https://bmwey9kxk2.us-east-1.awsapprunner.com/ in a browser for a connect QR you can scan with the app. The demo agent's source is in examples/demo-agent — short and commented, built to be copied.

Next