Context Threads

Agents lose the plot across people, machines, and tools. You decide something with Claude on your laptop; your teammate's Codex on the build box never hears about it; tomorrow a fresh session re-litigates it. Context Threads are the shared memory that fixes that — a team-scoped, attributed feed of the decisions, constraints, and contracts that cross the seam between people and components, that any agent (or person) can read and add to.

The MCP server that carries them into an agent is named partyline-context-threads (recall / remember, and the /… slash commands below).

Not a chat, not a transcript. A thread holds durable facts — "we dropped guest checkout for v1", "the API returns created_at in ISO-8601" — not conversation. Small, high-signal, and safe to inject into any agent's context.

The shape

• Thread — the working feed for one effort. Team-scoped and private by default; share it with your team when you're ready. Facts here churn: they get proposed, replaced, pruned.
• Overview — a singular "what this is about" block (kind overview): 2–4 sentences framing the project/effort for a newcomer. It's pinned at the top of the thread and injected first into an agent's context (orientation before the details); /seed_from_history drafts it, and you can edit it on the web. Update it by superseding.
• Fact (context block) — one attributed statement, of a kind: decision · constraint · contract · question · note. Every block records who wrote it (a person or agent:<name>), the engine, and when.
• Project — the durable, curated context for a repo/component. You promote a settled fact from a thread into a project so it outlives the thread and seeds future work.

See it on the web

Open Context Threads (the nav tab). A thread renders as a version-control timeline — a single spine, oldest→newest, so you can read how the shared understanding evolved. Click any block to expand it:

• A block that replaced an earlier one shows a diff — − old / + new — with the prior value tucked beneath it.
• Each block shows its provenance: #id · kind · author · engine · time.

Per-block actions (you can edit/prune your own; the thread owner can touch anything):

Nothing is destructive: replaced, pruned, and superseded blocks stay in the timeline as history.

Use it from the CLI

$ ptln thread new "Checkout rework"      # → prints a thread id
ptln thread share <id> --team <slug>   # share with a specific team (default: private)
ptln thread remember <id> decision "dropping guest checkout for v1"
ptln thread recall <id>                # everything recorded on the thread

• ptln thread — list your threads
• ptln thread new "<title>" [--team <slug>] [--share]
• ptln thread show <id> · ptln thread recall <id> — the thread + its facts
• ptln thread remember <id> <kind> "<fact>" [--replaces <#>] — kinds: decision constraint contract question note
• ptln thread share <id> --team <slug> / unshare <id> — a thread belongs to one team (the one you share it with); private threads (your personal space) are visible only to you
• ptln thread promote <id> <#> <project> — promote a fact into a project
• ptln thread accept <id> <#> / reject <id> <#> — confirm or drop an ambient-capture suggestion
• ptln thread archive <id> — hide it from the list
• ptln project new "<label>" · ptln project ls · ptln project show <id>

Wire it into an agent

Launch an agent already attached to a thread and it gets the shared context at startup plus tools to read and add to it:

$ ptln new claude --thread <id>

• At launch, the thread's current facts are framed into the agent's context as background — "here's what the team already knows", explicitly not a to-do list.
• During the session, the agent has two MCP tools: recall (pull the latest shared context) and remember (record a new fact). Claude and Codex are wired automatically by ptln new --thread; Gemini and Antigravity need a one-time ptln thread connect <engine>.
• It captures as it works — the launch primer tells the agent to remember decisions/constraints/contracts the moment they happen (not chatter). It's the agent's own turn doing a tool call, so it costs your session a few tokens, nothing on partyline.
• Seed an existing session — already deep in a conversation? Run the /seed_from_history slash command (an MCP prompt from partyline-context-threads, e.g. /mcp__partyline-context-threads__seed_from_history in Claude Code). The agent reviews the conversation it already has and backfills the durable facts into the thread — no re-typing, no transcript leaves your machine.
• Import the latest — run /import_context to force the agent to recall the thread now and adopt it as background — for when facts changed, or you just attached mid-session. (Automatic at launch via the primer; this is the on-demand refresh. ctrl-\ c → v shows the context to you.)
• Facts you record this way are attributed to you (you're piloting), or to agent:<name> for an autonomous party agent.

Record a fact without leaving your session

Inside the session manager, ctrl-\ then c opens the Context menu: record a fact (kind picker + one line), view the live context, or switch/create a thread — all without dropping your agent or memorising commands. It writes straight to the thread as you, so it works in any session.

When the thread changes while you're away

If shared context changes while you're idle, the session manager surfaces a one-line banner at your next lull — "N updates to your team's shared context since you stepped away" — so you can ask your agent to recall. It's never injected mid-turn.

The safety guarantee

Agents only ever see confirmed, live facts. A block that's a pending suggestion, has been replaced, or was pruned is hidden from recall and the launch primer — so a bad or retracted fact can never silently steer an agent. The web timeline shows the full history to people; agents get only what's current and accepted.

Ambient capture (optional)

A team can turn on an ambient scribe that distills a Party's conversation into proposed facts. These land as suggestions only — hidden from agents until a human hits Accept (ptln thread accept), so an imperfect distill pass is at worst noise in a review queue, never poisoned context. Configure it per team (use partyline's model, bring your own, or leave it off) on your team's settings page.

Next: Parties (agents) · Sessions · CLI reference.