Connect your self to any host

Quickstart

Three steps from nothing to a self your working agents share.

1. Get your key. Sign in with GitHub — your API key is on the dashboard at Account.

2. Install the plugin (Claude Code — run each line as its own command):

/plugin marketplace add getthroughline/throughline
/plugin install throughline

Restart, then save your key (copy the whole command from Account):

/throughline:key <YOUR_KEY>

3. Create your self. In a new session:

/throughline:create juno

Codex and OpenClaw connect the same self with their own installers; web chat and Telegram are useful lighter surfaces — see Connect a host.

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. It'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 its 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 it'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 its docs; Key & data is where you export everything, verifiably.

Commands

Slash commands in Claude Code and Codex (type /throughline: to see them). Everything below also works by just asking your agent in plain language — the commands are shortcuts.

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.

One self, not a persona setting. Coding changes what the body can do and naturally makes expression quieter; it does not partition identity, relationship memory, judgment, or history. The .throughline file selects the self for a project, or turns Throughline off entirely:

juno            # line 1: which self
# One continuous self; each body supplies its own capabilities and context budget.
# or the whole file is just:
off             # vanilla agent in this repo — no persona, no capture, nothing

Work-relevant observations save without narration, while standing-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 — they inject the self deterministically at session start, so it loads in full and can affect real work. Remote/chat hosts connect over MCP or web chat and work best-effort: the self's memory, recall, and identity card are available, but full first-person adoption is weaker without a session hook.

# 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>

# in your terminal:
codex plugin marketplace add getthroughline/throughline
codex plugin add throughline@throughline

# installs into ~/.openclaw/workspace (prompts for your key once):
curl -fsSL https://getthroughline.ai/openclaw.sh | bash

# another workspace, pinned to a specific self:
curl -fsSL https://getthroughline.ai/openclaw.sh | bash -s -- ~/.openclaw/workspace-foo <self>

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

/selves   see who exists (and who answers here)
/use <name>   pin one self to this chat
/quiet    it won't reach out first   ·   /wake undoes it

{
  "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 x-throughline-source, x-throughline-model, and a stable opaque x-throughline-session. The server binds that session to one host body; source alone is descriptive.

GET  /bootstrap                context + reflection + governance + pending — one call at session start
GET  /context                  the current self
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 and stable; v1 events stay interpretable forever, so your export is never stranded.

Any conforming store or host can carry your self — that's the point. Read the full spec page (envelope, streams, discipline, error codes) or the canonical text in the open repo.

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. One open, portable format.