Parlane

Quickstart

There are two honest paths here, and they end up in the same place. If you already have a backend you want to connect, use path A. If you just want to see the product working before you touch your own code, use path B.

Path A — make your own app ready

Paste this into Claude Code, Cursor, or whatever coding agent you already use. It reads the contract below and wires up your server to it.

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 10-minute number is a goal, not a guarantee. It assumes an agent that already talks to a model and can write a small amount of server code. If your backend already streams text and calls tools, most of this is copying the shapes below; if it doesn't exist yet, budget more time for that part — the contract itself is small.

Once your agent tells you it's done, validate what it produced againstspec/manifest.schema.json, spec/ui-document.schema.json, and spec/action.schema.json before you trust it — the schemas are the actual contract; this page is the readable companion to them.

Path B — try a reference server first

Two minimal reference servers exist purely as teaching material: a Node + Express implementation and a Python + FastAPI port of the same thing. Neither is a product — every file is short and commented so you can read it in five minutes and copy the pattern into your own backend, in any language.

Node + Express
cd examples/node-express
npm install
npm start

This prints the server's LAN URL and a QR code encodingparlane://connect?url=.... Scan it with the app and you're connected — no typing required. Set AUTH_TOKEN to require a bearer token; the printed QR carries it automatically.

Python + FastAPI
cd examples/python-fastapi
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python main.py

What you get either way

  • A manifest served at /.well-known/parlane.json (or the equivalent MCP resource).
  • Chat, streamed over Server-Sent Events or an MCP tool call.
  • Two dashboards rendered from JSON — read-only and interactive.
  • An action loop: a button calls a tool on your server, the server sends back a new dashboard.

Next