A shared memory your AI agents don't lose.
Your agents forget everything between sessions — and never hear what you decided with a different tool, on a different machine, or on a teammate's laptop. Context Threads give every agent one shared, attributed memory: it reads the team's decisions at launch and records new ones as it works.
Removing sign-up friction from checkout for v1. Guest checkout first, optional account after. Payments via Stripe.
$ brew install partyline-sh/tap/partylineWorks with Claude Code and Codex today. Context is scoped to you or your team, and agents only ever see confirmed, current facts.
You decide something with Claude on your laptop. Tomorrow's session re-litigates it. Your teammate's Codex on the build box never heard about it at all. 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 tools, that any agent (or person) can read and add to.
How it works
Attach a thread
Launch with ptln new claude --thread <id>, or attach a running session from the ctrl-\ c menu. The agent gets the team's current context at launch — not a to-do list, just “here's what we know.”
It captures as it works
The agent records decisions, constraints, and contracts the moment they happen — its own tool call, a few of your tokens, nothing on partyline. Already deep in a session? Seed it with /seed_from_history.
Everyone stays in sync
Your next session, your teammate's Codex, a fresh machine — all read the same live context. Edit it on the web; agents pull the latest with /import_context.
Where it shines
Stop re-explaining
Your morning session already knows what last night's decided.
Keep a pair in sync
Two people, two agents, one shared understanding — no standup to re-sync what the bots know.
Onboard an agent
Point a fresh agent at the thread and it starts with the team's decisions instead of a blank slate.
Frequently asked questions
What are Context Threads?
A shared, team-scoped memory for AI agents. A thread is an attributed feed of durable facts — decisions, constraints, contracts — that any agent or person can read and add to, across tools, machines, and sessions.
Which AI tools can use shared context?
Claude Code and Codex are wired automatically when you launch with --thread. It's delivered over MCP (the partyline-context-threads server: recall / remember), so any MCP-capable tool can read and write.
How is this different from a CLAUDE.md file or a prompt?
A file is per-repo, per-tool, and unattributed, and nobody keeps it current. A thread is shared across people and tools, records who said what and when, versions every change, and agents keep it up to date as they work.
Do agents ever see wrong or retracted facts?
No. recall and the launch primer only ever return confirmed, live facts. Proposed suggestions, replaced facts, and pruned facts are hidden from agents — the full history stays visible to people on the web, not to agents.
Is my context private?
Threads are private to you by default; you share one with a specific team when you're ready. Access is row-level scoped to your account or that team.
What does it cost?
Recording context is your agent's own tool call — it costs a few of your session's tokens and nothing on partyline. Shared context is included on every plan.
Give your agents a memory.
$ brew install partyline-sh/tap/partyline