`context store` / `recall`: passing state between agents without copy-paste

Copy-pasting one agent's output into another is the sneakernet of the AI era. rysh's context tool moves state through JetStream KV instead.

Somewhere right now, a developer is selecting four thousand words of one agent's output, hitting Cmd+C, clicking into a different agent's input box, and hitting Cmd+V.

This is the sneakernet of the AI era. We built autonomous agents that can drive browsers and refactor codebases, and then we made a human courier walk their findings across the desktop by hand.

Copy-paste handoffs fail the same three ways floppy-disk handoffs did: they're lossy (you always grab the summary and lose the table that mattered), manual (a human must be present, so nothing composes), and unrepeatable (next week, nobody can reconstruct what exactly agent B was given).

The tool

rysh gives agents a context tool with three actions: store, recall, list. Values live in JetStream KV — the persistence layer of the embedded NATS server that runs inside every rysh session.

The flow is exactly as boring as it should be:

• A research agent finishes an audit and calls context store with a key like auth-audit and the findings as the value.
• An implementation agent — different pane, different skill file, possibly a different day — calls context recall with auth-audit and starts working from the actual findings, not a human's abbreviated retelling of them.
• list is discoverability: what handoffs exist in this session right now?

No clipboard. No human courier. No "hang on, let me find that output."

Named handoffs beat shared windows

There's a deeper design argument here than convenience.

The fashionable alternative is the giant shared context: pile every agent's transcript into one enormous window (or one vector store) and let everything see everything. It feels powerful and degrades terribly — everything couples to everything, no one can say what any agent actually consumed, and your token bill becomes a haunted house.

context keys push the other way: small, deliberate interfaces between agents. The researcher doesn't export its stream of consciousness; it exports auth-audit — a named artifact with an intended consumer. Key names become the API between your agents, and the same discipline you'd apply to function signatures applies here: name things well, keep payloads focused, don't pass the whole world.

This composes naturally with skill files. An agent defined in markdown can bake the handoff into its standing instructions — a reviewer skill whose first step is "recall release-notes-draft before reviewing" is a pipeline stage, defined in a file, versioned in git. Chain a few of those and you have a multi-agent workflow with no orchestration framework in sight — just named state and agents that know which names they own. For live streaming between panes there's ##pane listen; context is its durable, addressable sibling.

The mechanics, briefly

Nothing exotic — which is the point:

• Durable. JetStream KV persists across detach, reattach, and session restarts. A handoff stored on Friday is recallable on Monday.
• Session-scoped. Keys live in your session's KV, on your machine or server — self-hostable like the rest of rysh. No third-party memory service is holding your agents' working state.
• Observable. A store or recall is a visible tool call in the pane, like every tool call in rysh. When agent B acts strangely, you can see exactly which context it pulled and what was in it. Try auditing that with a clipboard.

What it deliberately is not

Honesty section, because "agent memory" is a phrase that launders a lot of wishful thinking:

• It's not automatic. Nothing is stored unless an agent (or its skill file) stores it; nothing is recalled unless something asks. There's no ambient recall engine deciding what's relevant. We consider that a feature: predictable beats magical when the payloads are things like audit findings that drive code changes.
• It's not semantic search. Recall is by key, not by vibes. If you don't know the name, list is the phone book.
• It's not long-term memory. For durable prose that should outlive sessions — conventions, hard-won gotchas — that's RYSH.md and project notes, which live as files in your repo. context is working state: the baton, not the library.

The baton metaphor holds up well, actually. Relay teams don't hand off by having the second runner re-run the first leg (re-prompting from scratch), and not by shouting a summary across the track (copy-paste). They pass one deliberate object, in a marked zone, and the judges can see the exchange.

Your agents deserve the same. Stop being the courier.

We're recruiting design partners. If your team is wiring multiple agents together and still ferrying state by clipboard, come build the handoff layer with us: rysh.ai/design-partner

Related: RYSH.md and project notes: durable memory for a workspace · session_history: agents that read the room