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.
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.
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.
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.
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.
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.
Check receipt and terminal streaming events. Record any failure without calling it a saved memory.
Verify the durable write separately, including provenance and unverified review state.
Retrieve in a fresh web session and a second tested client without copying the briefing into the question.
Correct the criterion through the supported review flow, then check which version the next answer uses.
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.
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
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.
To: your Emily
Subject: Re: vendor shortlist
Can you check this quote against what we agreed last month?
Emily replied
On 12 September you capped support at 15% of the licence cost. This quote is at 22%, so it is over the limit you set. Want me to draft a reply asking them to revise it?
source verification neededwrite outcome not demonstrated
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.
Brightpath.
Your coaching space
Career next steps
Weekly reflection
Presentation prep
+ New session
Career next steps
Coach
I've got the interview Thursday. Can we practise?
Yes. Last time you wanted to sound more confident about the budget project, so let's start there.
Type a message…
A branded coaching app
A web front end in your stack. Your backend calls Emily and streams each reply to the page.
Cedarline
Ask Cedarline
Which plan did I pick last month?
The Family plan, on 12 September. Want me to compare it with the new one?
Ask a question
A help widget on your website
Embed Emily in a product you already run. Sessions and sign-in stay with your app.
HALO
Summarise the doc I sent
Three key points, and one risk you flagged before…
Hold to talk
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
You build
Your interface
The screens, branding and workflow your people see.
Robson runs
Sign-in and access
Every request is authenticated by Robson, wherever your interface runs.
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/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.
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 path
Use
Credential
POST /auth/sdk/device
Start S256 PKCE device approval
None
GET /auth/sdk/device/verify
Emily-hosted sign-in and consent page
Emily browser session
POST /auth/sdk/device/token
Exchange the approved device code
Device code and PKCE verifier
POST /auth/sdk/refresh
Rotate the token pair
Refresh token in body
POST /auth/sdk/logout
Revoke the connection (returns 204)
Refresh token in body
GET /auth/status
Check the token's account status
Bearer access token
GET /api/sdk/capabilities
SDK contract and supported chat routes
Bearer access token
GET /api/sdk/clones
List targets; select account_self
Bearer access token
POST /api/sdk/clones/resolve
Confirm the personal target
Bearer access token
POST /chat/v3
Send a message, receive SSE
Bearer + clone_id
GET /chat/last-turn
Look up an exact completed turn
Bearer + clone_id
GET /chat/turn/client/{client_turn_id}
Look up an exact submitted turn
Bearer + clone_id
GET /chat/turn/{turn_id}/stream
Reattach to or replay a turn
Bearer + clone_id
GET /chat/session/{session_id}/active-turn
Find a session's active turn
Bearer + clone_id
POST /chat/turn/cancel
Stop an active turn
Bearer + 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.