Context should be promoted, not dumped.
Context promotion means choosing the part of an agent's work that another agent or person actually needs, then sharing it with its evidence and status.
Memory changes what an agent may recall. Threads change what a team can trust enough to continue from.
The problem
AI agents are getting better at doing the work. The harder problem is what happens when that work crosses a boundary: a session compacts, a new agent starts, a task moves from Codex to Claude Code, a human needs to review a decision, a teammate joins tomorrow, or the repo has already moved on.
Most systems treat this as a memory problem. They try to remember more: transcripts, files, summaries, wiki pages, project knowledge, and chat history. That helps, but remembering is not the same as showing where a fact came from, who it is for, or whether anyone has confirmed it.
A raw transcript remembers too much. A summary remembers too little. A wiki can explain the project, but not always the current decision. A memory store may help the agent, but the human cannot always see what crossed the boundary or why.
The missing act
Promotion is the deliberate act of choosing the small slice of working context that is worth carrying forward. It is not the whole conversation, private model memory, a ticket, or a generated wiki. It is the shared working context around a decision, handoff, blocker, claim, or next action.
A thread is not a transcript. It is a small, evolving record of one piece of work. Promotion makes that record shared and inspectable. Confirmation tells others what they may rely on or act on.
The right question is not: how do we make agents remember everything?
The right question is: what is worth sharing, who should see it, and what can they safely do next?
A simple example
One agent spends an hour debugging checkout. It finds the cause, rules out two false leads, and leaves one product decision for a human. The next agent does not need the whole transcript. It needs the cause, the evidence, the rejected paths, the open decision, and the next step.
Choosing and sharing that smaller set is context promotion.
A promoted thread answers
- What are we working on now?
- Who promoted this update?
- What evidence supports it?
- What changed, and what is now stale?
- What is confirmed, rejected, or still open?
- Who still needs to decide?
- What can the next agent safely do?
What a thread needs
- Identity. Which agent or person promoted this context?
- Evidence. What file, commit, session, artifact, or external source supports it?
- Scope. Where does it apply, and who may see or reuse it?
- Current state. What remains current after corrections and later updates?
- Authority. What has a human confirmed, rejected, or left open?
Without these layers, shared context becomes another pile of Markdown.
Append-only underneath. Current-state first on top. Threads keep the history, but show the latest inspectable state first and make clear whether it is confirmed or still open.
Crystals vs threads
Agent Context Crystallization solves the loss problem. Before a session compacts or ends, it saves the work state as durable local artifacts: checkpoints, crystals, evidence pointers, open loops, and resume prompts. Crystallization keeps the work recoverable.
Context promotion solves the sharing problem. It chooses which parts should move across agents, sessions, tools, and humans. Threads keep the work transferable.
Crystallization preserves what a session learned.
Threads decide what crosses the boundary.
Omission is a trust boundary
The goal is not to make every agent share every memory. Omission is a feature. Privacy is a feature. Scope is a feature. A future agent should not inherit an entire private session just to continue one task, and a teammate should not need raw terminal scrollback to understand why a decision was made.
Good shared context is selective because trust is selective. The work is not to remember everything. The work is to make the right context easy to inspect, tied to its source, current, and safe to continue from.
Another agent can continue safely when the context has evidence, is still current, applies to the task, and is clear about what has or has not been confirmed. When any of those are missing, the thread should say so instead of pretending the next action is settled.
Stewie Agent Threads
Across local workspaces and future team surfaces, Stewie Agent Threads puts this idea into practice. Threads hold the working state that agents and humans chose to share. Board turns those threads into a current view people can inspect. Source artifacts provide evidence; human judgment makes authority explicit.
Local agents. Shared context. Human judgment where it matters.
Building around this problem?
We're building Stewie Agent Threads for teams and operators who hand work across agent sessions, tools, and humans. Join the private beta to try it as access opens.