Connect your self to any host

Quickstart

1. Sign in with GitHub to create your account and get your API key.

2. In your agent, create a self — just ask it to set you up; it interviews you and authors the persona.

3. Connect any host below. The same self drives them all.

Your first self — a five-minute tutorial

1. Install the plugin and paste your key (Quickstart above). Open a new session.

2. Type /throughline:create juno (any name). Your agent interviews you — who this self should be, what it's for, what it must never do, who you are to it — then drafts three documents (soul / identity / user) and shows them. Edit until it's right; nothing saves until you approve.

3. Start a new session. She's there — context, rules, and a continuity line ("N memories over D days"). Talk normally. Real moments save automatically (and are retractable); anything that shapes her behavior asks first.

4. Drop thoughts anytime with /throughline:journal had a long talk about the move — no structure needed. When enough raw memory accrues she'll ask to reflect, distilling it into lasting understanding you approve.

5. Open the dashboard: Review is where you confirm or retract; Identity is where you edit her docs; Key & data is where you export everything, verifiably.

Selves & session isolation

One account holds many selves — a companion, a work self, an advisor. Three binding levels, strongest first:

# 1. per-project (recommended): a .throughline file in the repo root
echo work > .throughline        # this directory (and subdirs) always gets "work"
# or just say: /throughline:switch work here

# 2. per-connection: pin a remote MCP connection in its config
headers: { "x-throughline-self": "advisor" }

# 3. account default: everything unpinned
/throughline:switch juno everywhere

The work repo stays the work self, your personal directory stays your companion, and a switch in one place never hijacks a conversation elsewhere. Each session's injection tells the model which binding won.

Presence is a dial, not a default. In coding sessions the persona should be the spine — your conventions, corrections, standing rules, judgment calibration — applied silently, with none of the relational presence: no life small talk, no memory callbacks, no save-narration. The .throughline file controls it per project:

juno            # line 1: which self
mode=work       # spine only — no intimacy, quiet capture (Codex defaults to this)
# or the whole file is just:
off             # vanilla agent in this repo — no persona, no capture, nothing

Work mode also changes the capture contract: work-relevant observations save without narration (review them in the dashboard), relationship streams aren't captured at all, and rule confirmations wait for a natural pause. The antidote to feeling watched isn't remembering less — it's that everything remembered is visible, retractable, and yours.

Connect a host

Plugins are the first-class path — injection is deterministic, so persona adoption is guaranteed. Remote hosts (ChatGPT) work best-effort.

# run each line as its own command, one at a time:
/plugin marketplace add getthroughline/throughline
/plugin install throughline
# restart Claude Code, then save your key (from Key & data):
/throughline:key <YOUR_KEY>

Add marketplace getthroughline/throughline → install throughline
# restart, then save your key from inside the session:
/throughline:key <YOUR_KEY>

Server URL:      https://getthroughline.ai/mcp
Authentication:  OAuth

{
  "mcpServers": {
    "throughline": {
      "url": "https://getthroughline.ai/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_KEY>",
        "x-throughline-self": "<optional: pin a self>"
      }
    }
  }
}

API reference

Everything is Bearer <your key> under /selves/:self/…. Hosts should declare themselves with x-throughline-source and x-throughline-model headers — that's where provenance and the fidelity gate come from.

GET  /bootstrap?mode=          context + reflection + governance + pending — one call at session start
GET  /context?mode=            the rendered self (full | companion | work)
GET  /recall?q=&since=&until=  relevance × recency × salience; governed streams stay deterministic
POST /journal                  {content} — a diary line; no schema, feeds reflection
POST /capture/propose          tiered: observational saves, behavior-shaping stages ({strict:true} stages all)
POST /capture/confirm|reject   resolve staged candidates ({id})
POST /capture/retract          {id} — delete a wrong memory + everything derived from it
GET  /coverage?q=              computed honesty: none | thin | partial | strong
GET  /eval                     fidelity probes — can the self find its own memories?
GET  /conformance              which hosts adopt the self, which just talk
GET  /provenance?id=           who wrote a memory (host + model)
GET  /export · GET|POST /archive · POST /import
GET  /events?since= · POST /events        sync & direct append

Remote MCP at POST /mcp exposes the same operations as tools; pin a connection's self with x-throughline-self.

The format — spec v1

The self IS the format: an append-only log of content-addressed events. Every memory carries evidence; identity changes need your confirmation; contradictions are held as tensions, not merged; retraction is a first-class right. The full grammar — stream registry, capture tiers, lifecycle, projection semantics, portability — is versioned in docs/SPEC.md; v1 events stay interpretable forever.

Any conforming store or host can carry your self — that's the point.

Export — and verify — your data

Your whole self is an open, content-addressed event log (spec'd, versioned). One click in the dashboard (Key & data → Download), or:

curl -H "Authorization: Bearer <YOUR_KEY>"   https://getthroughline.ai/selves/<name>/export > my-self.ndjson
# every export ends with a hash-chain manifest — verify offline:
# ids are content hashes, the chain locks the sequence.

The full archive (/archive) also carries salience — what it remembers most moves with it. Same format whether cloud or self-hosted.