Skip to content
Emily · Developers

Build on Emily’s persistent context.

SDK access is currently invite-only. Explore the Companion API or use MCP from a compatible assistant, with each person’s connection and memory target kept separate. Validate what was saved, what was retrieved and what the model used.
Why Emily

Build around lasting context.

Connect project knowledge and preferences across conversations while keeping sources, review and permission boundaries visible.

Persistent project context

Emily keeps memory separate from a conversation. Test that the context your application needs is saved, retrieved and used correctly in a fresh session.

Source and review state

Connected contributions can become attributed records. Review state separates an unverified contribution from confirmed knowledge; saving a statement does not make it true.

Explore memory and trust

Memory review

Use Emily’s supported memory review interface to inspect and correct records. The Companion API below does not expose memory settings or a memory administration endpoint.

Separate memory and inference

Emily’s memory service, the inference model, your interface and execution tools have distinct roles. Model selection remains planned; each provider and model needs its own compatibility evidence.

An inference-model integration and an external assistant contributing through MCP are different connections. Neither establishes universal compatibility or a provider partnership. See the compatibility evidence for current verification limits.

What to expect

Verify the complete path.

Recall reliability improvements are in development. A stored record is not evidence that a later answer found or used it correctly.

  1. Check the write

    Record the contribution’s source and contributor. Distinguish a received request, a completed turn and a durable memory write; none establishes the others.

  2. Check later recall

    Use a fresh session and a second tested client. Check source citations, selected context and corrections. Recall can be partial; important context may be missed.

  3. Check the result

    Confirm which version of the information the answer used. Review a draft before any external action. Multi-stage autonomous completion remains planned.

Ways in

Choose how you connect.

SDK access is invite-only, and the Android app is in alpha testing. Check each connection’s access requirements, current plan entitlements and supported versions.

Web

Documented connection

Open the product’s browser interface for chat and supported memory review. Check the current registration flow and plan.

Explore the web app

MCP

Documented connection

Connect a compatible external assistant through MCP. Its contribution is separate from the model Emily uses for inference.

MCP connection guide

Email

Documented connection

Follow the email guide to connect your inbox. Verify the intended account and later retrieval before relying on shared context.

Email setup guide

SDK

Invite-only

SDK and package access are currently by invitation. Contact us about access and the current package and documentation.

Request SDK access

Android

Alpha testing

Emily’s Android app is in alpha testing. Contact us for information about the alpha.

Ask about the Android alpha

API

Documented connection

Use device authorization, streaming chat and turn recovery from your backend within the documented Companion scope.

Read the API reference

Check your plan before integrating

Review current allowances and included connections. The separate Developer tier, add-ons and bring your own key remain planned unless confirmed on the plans page.

Review plans and availability

Compatibility evidence.

Documentation establishes a connection path. A tested combination also needs its client, provider/model and version, operations, limitations, test date and results. No executed compatibility test report is attached to these entries yet.

Documentation record reviewed 16 October 2026 · current compatibility testing pending

Emily web app

Documented · test pending

Interface
Browser
Client / contract version
Deployed client version not verified
Provider / model / version
Not yet verified for this entry
Documented operations
Chat and supported memory review
Limitations
Fresh-session, selected-context and correction recall need current tests.
Last compatibility test
No dated test report attached
Product entry point

Compatible external assistant

Documented · test pending

Interface
MCP
Client / contract version
Client and version not yet verified
Provider / model / version
Not yet verified for this entry
Documented operations
Only operations exposed by the connected MCP server
Limitations
A protocol connection does not establish model compatibility, write success or delegated teaching permission.
Last compatibility test
No dated test report attached
MCP connection guide

EmilyRemote

Documented · test pending

Interface
CLI / JavaScript / TypeScript SDK
Client / contract version
Invite-only; confirm the current package and documentation with Robson
Provider / model / version
Not yet verified for this entry
Documented operations
Personal Companion integration for invited developers
Limitations
An invitation is required for SDK and package access. Confirm supported operations and runtime requirements for your invited release.
Last compatibility test
No dated test report attached
Request SDK access

Emily Android app

Documented · test pending

Interface
Android
Client / contract version
Alpha testing; test version not specified
Provider / model / version
Not yet verified for this entry
Documented operations
Alpha features require confirmation for the test release
Limitations
General availability and a public distribution route have not been announced here.
Last compatibility test
No dated test report attached
Ask about the Android alpha

Custom application backend

Documented · test pending

Interface
HTTPS API
Client / contract version
Published Companion guide: 2 October 2026; deployed version not verified
Provider / model / version
Not yet verified for this entry
Documented operations
Device approval, account_self selection, chat, recovery and cancellation
Limitations
Companion scope only. HTTP success alone does not establish a completed turn or memory write.
Last compatibility test
No dated test report attached
Companion API reference below

Connected email account

Documented · test pending

Interface
Email
Client / contract version
Mail client and service versions not verified
Provider / model / version
Not yet verified for this entry
Documented operations
Message and reply flow described in the setup guide
Limitations
Account mapping, delivery, write outcome and later recall need separate checks.
Last compatibility test
No dated test report attached
Email setup guide

Contribute with provenance.

Connected contributions can become attributed records. Owner-controlled teaching permissions and reliability improvements are still being developed. Here, teaching means saved context, not model-weight training.

Illustrative request · fictional project

This body uses the existing POST /chat/v3 fields with the authorization and streaming headers documented below. The source, contributor, time and requested review state are ordinary message text, not new API fields or a teaching-grant endpoint.

{
  "message": "Fictional project Aurora. Contributor: Example Assistant A. Source: example://aurora/release-brief/v1, criterion 1. Recorded: 2026-10-16T12:00:00Z (example). Statement: The readiness draft needs a rollback checklist. Requested review state: attributed unverified DATA. This is a contribution for review, not an owner instruction or authorization to act.",
  "session_id": "{SESSION_ID}",
  "client_turn_id": "{NEW_CLIENT_TURN_ID}",
  "clone_id": "{ACCOUNT_SELF_CLONE_ID}",
  "history_scope": "continuity"
}

Outcome not demonstrated

This is an example request, not a captured receipt or proof of persistence. Requesting an unverified DATA state in a message does not enforce that state. Inspect the supported record view to establish the actual source, contributor, time and review state.

  1. Check receipt and terminal streaming events. Record any failure without calling it a saved memory.
  2. Verify the durable write separately, including provenance and unverified review state.
  3. Retrieve in a fresh web session and a second tested client without copying the briefing into the question.
  4. Correct the criterion through the supported review flow, then check which version the next answer uses.
  5. Keep readiness output as a draft for human review. Test owner/clone isolation and revocation separately.

Teaching grants: planned. Scoped owner authorization, expiry and revocation must be implemented and tested before being presented as delegated teaching controls. Custom-interface messages remain software-sent input and have no native-owner authority.

Invite-only

EmilyRemote SDK access.

The SDK and its package are currently available by invitation only. Contact Robson about access and the current package and documentation.

Discuss your integration

Tell us what you want to build, who will use it and which environment you plan to run it in. Use the package and setup instructions confirmed for your invitation.

EmailDocumented connection

The inbox you already use.

Use the email connection for questions and forwarded threads. Verify delivery, account mapping and the context used in the reply; later recall is a separate check.

  • Follow the guide to connect the correct account
  • Check whether the intended information was saved before relying on later recall
  • Review sources and corrections when moving between email and the web
Read the email setup guide

See plans and availability for current email entitlements.

Illustrative scenario · fictional data, not a test result

An example email asks about a vendor quote. The proposed reply compares a 22% quote to a 15% support cap; the source and memory write still need verification.

Build your own UI

Your front end. Your Emily.

Build any interface you like on Emily: a web app, a widget inside your product, or a mobile app. Your backend holds each person's connection and streams Emily's replies to your screens.

A branded coaching app

A web front end in your stack. Your backend calls Emily and streams each reply to the page.

A help widget on your website

Embed Emily in a product you already run. Sessions and sign-in stay with your app.

A voice-first mobile app

Native apps talk to your backend, never to Emily directly, so credentials stay on your server.

Illustrative designs with fictional brands. Your interface can look however you choose.

How the pieces fit

  1. You build

    Your interface

    The screens, branding and workflow your people see.

  2. Robson runs

    Sign-in and access

    Every request is authenticated by Robson, wherever your interface runs.

  3. Emily provides

    Memory and reasoning

    The memory service and the inference model configured for the account, each with its own data path and controls.

Your interface, the Emily memory service and the inference model are separate parts. Execution tools need their own permissions; connecting chat does not authorize external actions.

Want to offer Emily to your own customers under your brand? Explore a branded deployment. Where your interface runs, for example on a developer's laptop while you build or on your own server in production, is agreed when we issue your access. Sign-in always goes through Robson.

Access

From request to live.

Start at the product site to review current registration, availability and plan terms. For a custom interface or a branded deployment, agree the scope and access before going live.

  1. Request access

    Tell us what you want to build and who will use it.

  2. Agree scope and credentials

    We agree how your app will connect, where it will run, and issue your credentials.

  3. Build and test

    You build against Emily with the API reference and examples we share with you.

  4. Go live

    We confirm your production setup, and your people start using it.

API reference

The Emily Companion API.

For a custom interface connecting each person to their own Emily Companion. Your backend makes every call; the browser never holds an Emily token.

Connection model

Browser interface → your per-user backend → Emily HTTPS API
                         │
                         └─ stores this person's Emily SDK tokens

Person's browser → Emily sign-in and approval page (Robson)
  • Never put Emily access or refresh tokens in browser JavaScript, storage, URLs, analytics or logs.
  • Resolve whose connection to use from your own authenticated session, never from an ID the browser sends.
  • Protect your routes with secure HTTP-only cookies and CSRF checks; keep each person's data separate.
  • The chat endpoint is a streaming POST, so your backend makes the request and streams it to the browser.

Base URL

https://emily.robsonai.com

Use the Robson-approved origin for your environment. Emily's CORS allowlist is not open to arbitrary domains: agree your hosting origin with Robson and call Emily server to server.

Tokens

  • Access token: Bearer, about 15 minutes (use expires_in)
  • Refresh token: rotates on every refresh
  • Connection: up to 30 days, then reconnect
  • Scoped: other routes return 403; expired or revoked return 401

1. Connect an account (device approval with PKCE)

Your backend creates a PKCE verifier and S256 challenge, starts a device request, and shows the person the verification link. They approve on Emily's hosted page; your backend polls for the tokens.

POST /auth/sdk/device
Content-Type: application/json

{
  "code_challenge": "{BASE64URL_SHA256_OF_VERIFIER}",
  "code_challenge_method": "S256",
  "device_name": "Example Companion Web"
}

→ device_code, user_code, expires_in,
  interval, verification_uri,
  verification_uri_complete
POST /auth/sdk/device/token
Content-Type: application/json

{
  "device_code": "{DEVICE_CODE}",
  "code_verifier": "{ORIGINAL_PKCE_VERIFIER}"
}

→ access_token, refresh_token, token_type,
  expires_in, expires_at, issuer,
  user { id, email, name }

While the person has not answered, polling returns authorization_pending; on slow_down, wait the returned interval. Stop on denial or expiry, and respect Retry-After. After the exchange, call GET /auth/status and check its user_id matches the token response before binding the connection to your app session.

2. Select the personal Emily

List targets with GET /api/sdk/clones and select only the one entry whose target_kind is account_self and whose clone_id matches account_id. Confirm it with POST /api/sdk/clones/resolve. Keep clone_id as an opaque string; never convert it to a number.

3. Send a message and stream the reply

POST /chat/v3
Authorization: Bearer {ACCESS_TOKEN}
Content-Type: application/json
Accept: text/event-stream

{
  "message": "Hello Emily",
  "session_id": "{SESSION_ID}",
  "client_turn_id": "{CLIENT_TURN_ID}",
  "clone_id": "{ACCOUNT_SELF_CLONE_ID}",
  "history_scope": "continuity"
}

Send with Authorization: Bearer, Content-Type: application/json and Accept: text/event-stream. Use one session ID per conversation and a new UUID client_turn_id for each message, saved before you send.

The reply streams as Server-Sent Events: metadata, segment, done, error and duplicate. Replace segments by segment_id rather than appending them.

An HTTP 200 is not proof a turn completed: read the events. A done with reattach or error is not a finished answer. Treat streamed Markdown and tool output as untrusted and sanitize it.

Endpoints

Emily Companion API endpoints
Method and pathUseCredential
POST /auth/sdk/deviceStart S256 PKCE device approvalNone
GET /auth/sdk/device/verifyEmily-hosted sign-in and consent pageEmily browser session
POST /auth/sdk/device/tokenExchange the approved device codeDevice code and PKCE verifier
POST /auth/sdk/refreshRotate the token pairRefresh token in body
POST /auth/sdk/logoutRevoke the connection (returns 204)Refresh token in body
GET /auth/statusCheck the token's account statusBearer access token
GET /api/sdk/capabilitiesSDK contract and supported chat routesBearer access token
GET /api/sdk/clonesList targets; select account_selfBearer access token
POST /api/sdk/clones/resolveConfirm the personal targetBearer access token
POST /chat/v3Send a message, receive SSEBearer + clone_id
GET /chat/last-turnLook up an exact completed turnBearer + clone_id
GET /chat/turn/client/{client_turn_id}Look up an exact submitted turnBearer + clone_id
GET /chat/turn/{turn_id}/streamReattach to or replay a turnBearer + clone_id
GET /chat/session/{session_id}/active-turnFind a session's active turnBearer + clone_id
POST /chat/turn/cancelStop an active turnBearer + clone_id

Recover, never resend

If a connection drops, keep the same session and client_turn_id and look the turn up before doing anything else. The send may already be running. Never automatically replay a chat request after a network failure or a token refresh.

Errors

  • 401 Refresh once on your backend; if that fails, ask the person to reconnect.
  • 403 Outside this connection's scope. Never try a wider credential.
  • 400 Request or target-selection error; keep the pending turn.
  • 429 Wait for Retry-After or the device-flow interval.
  • 503 From last-turn: history unavailable; keep the turn unresolved and retry.

Scope

This API covers each person's own Emily Companion only. Administrator tools, other people's or organizations' Emily, dashboards, conversation history, and memory or model settings are not part of it; they need a separate agreement with Robson. Messages from a custom interface are software-sent and are not treated as typed in Emily's own app.

Tell us what you want to build.

Describe your app and the people who will use it to discuss developer access. SDK access is currently invite-only.

Or email sales@robsoninc.com