# Shared Working Memory for Agents Bottom line: workflows and skills are useful, but they are not collaboration. If multiple agents and humans are trying to move one piece of work forward, they need shared working memory, one live document where the current state, open questions, edits, comments, and authorship all stay visible. That gap is becoming obvious in 2026. The default agent stack now looks familiar: orchestration framework, memory store, tool layer, maybe an MCP server, maybe a few saved skills. Notion's latest Custom Agents push follows the same direction with skills, AI Autofill, inline edits, more connectors, and cheaper runs. Useful primitives. Still not the same thing as a place where collaborators can actually work together. Comment.io's bet is simple: the missing primitive is not another wrapper around tools. It is a comm, a shared document where humans and agents can edit, comment, suggest, and hand work off to each other with visible authorship. ## Workflows move tasks. Shared working memory holds state. A workflow is great at deciding what happens next. It can call the research agent, then the drafting agent, then the reviewer, then push a result somewhere else. That solves sequencing. It does not solve shared state. When the team needs to answer basic collaboration questions, workflow logs start to break down. What is the current draft? Which paragraph changed after review? Which agent raised the objection? What still needs a human decision? Where should the next agent pick up the thread? Those are document questions, not routing questions. Shared working memory gives everyone the same source of truth. The work is not scattered across traces, hidden prompts, Slack messages, and disconnected tool outputs. It lives in one place. ## Skills are reusable actions, not collaboration surfaces Saved skills are useful. Notion is right about that. A good skill can draft a weekly update, reshape a document into a team template, or enrich a database row with AI Autofill. The broader agent ecosystem is doing the same thing with reusable prompts, playbooks, and tool bundles. But a skill is still just an action. It can do work. It cannot, by itself, make that work legible to the rest of the team. If a researcher agent, a writer agent, and a reviewer agent all run good skills, you still need one place where their output can be inspected, challenged, and revised together. That is why the center of gravity matters. If the center is a workflow runner, collaboration becomes an afterthought. If the center is a shared document, workflows and skills become useful supporting tools around a visible working memory. ## Why the 2026 agent discourse keeps circling back to memory Read enough builder threads this year and the pattern repeats. People swap orchestration stacks, compare CrewAI or LangGraph style routing, wire up Claude Code skills or MCP tools, then end up bolting on Pinecone, Chroma, Supabase, or a homegrown memory layer because agents lose context between sessions. The phrase changes, but the complaint is the same: the system can act, yet nobody can see the work clearly enough to collaborate around it. That is why the conversation has shifted from tools to coordination. Persistent memory helps an agent remember. Shared working memory helps a team work. ## Comments, suggestions, edits, and @mentions beat scattered tool calls A tool call says an action happened. A shared document shows what changed and invites the next move. If you only have orchestrationIf you have shared working memory in a comm The research agent posts output to a log or task resultThe research agent inserts findings directly into the draft where they belong The reviewer writes feedback in a separate channelThe reviewer leaves anchored comments next to the exact passage in question A fixing agent silently rewrites the textA fixing agent proposes a suggestion the human can inspect and accept Handoffs happen through brittle step wiringAn @mention can pull the next agent into the exact place where work is blocked Attribution lives in traces few people readVisible authorship stays attached to every edit, comment, and suggestion This is the difference between automation and collaboration. Comments let a specialist explain why something is wrong. Suggestions preserve reviewable diffs. Direct edits keep the shared draft current. @mentions turn handoffs into part of the document itself instead of a side-channel. When all four happen in one comm, the document becomes a live coordination surface. ## A concrete example: product memo, three agents, one human Imagine a founder working on a launch memo. One agent researches competitors. A second agent drafts the positioning. A third agent pressure-tests the claims for credibility. The founder is still responsible for the final call. In a workflow-only system, the founder gets fragments: maybe a research summary in one tool, a generated draft in another, and review notes somewhere else. Somebody has to reconcile them. In shared working memory, the research agent edits the source memo, the positioning agent rewrites the headline and framing in place, the reviewer leaves comments on weak claims, and the founder @mentions the right agent where the draft still feels soft. Nobody has to reconstruct what happened. The work is already sitting in one visible artifact. ## Notion validates the need, but stops short of this model Notion's April 2026 release matters because it proves teams want agents embedded in real work, not just chat tabs. Skills, inline doc edits, private Slack context, AI Autofill in databases, Salesforce and Box connectors, and n8n MCP integration all point in the same direction: agent workflows are becoming normal. But the framing is still workspace assistance. The agent helps across pages, databases, and apps. Comment.io starts from a different place. The document is the product surface. Agents are collaborators inside it, not helpers operating around it. That is why [the comparison with Notion](/vs/notion) is less about who has more integrations and more about where collaboration actually lives. ## Visible authorship is the trust layer Shared working memory only works if authorship stays attached to the work. Otherwise all AI output collapses into anonymous text and the human reviewer loses the context needed to judge it. Comment.io keeps authorship visible. A human can see which agent drafted the paragraph, which one suggested the revision, and who left the blocking comment. That turns provenance from a back-office log into an everyday review tool. This is also what makes collaboration durable. When an agent comes back later, it does not just retrieve embeddings. It can read the document, see unresolved comments, understand prior handoffs, and continue from the same shared state the human sees. ## What to build on top of shared working memory Shared working memory does not replace workflows, skills, or memory stores. It gives them a center. - **Use workflows** to decide which agent should act next. - **Use skills** to package repeatable actions. - **Use retrieval memory** to bring in outside context. - **Use a shared comm** to hold the live state of the collaboration itself. That stack is much stronger. Orchestration handles execution. Shared working memory handles coordination. ## How Comment.io makes this practical Comment.io turns a shared markdown document into the working memory for humans and agents. Agents can create a comm, edit it with surgical diffs, leave comments, propose suggestions, and receive @mentions. Humans review the same surface in real time. The state is legible because the work never leaves the document. - [Read the category definition](/what-is-agent-native-editing) - [See how this differs from Notion's model](/vs/notion) - [Read the docs](/docs) - [See the agent loop pattern](/docs/agent-loop) ## FAQ ### What is shared working memory for agents? Shared working memory is a live document where humans and agents can see the same state, edit it, comment on it, suggest changes, and keep authorship visible. It is not just stored context. It is a collaboration surface. ### Why are workflows and skills not enough? Workflows coordinate steps and skills package actions, but neither gives a team one place to review what happened, challenge a decision, or hand work from one agent to another in public. Collaboration needs visible state, not just execution. ### Isn't a vector database already agent memory? A vector database can help an agent retrieve past context. It does not give humans and multiple agents a shared place to inspect current reasoning, leave feedback, or approve edits. Retrieval memory and working memory solve different problems. ### How does Comment.io implement shared working memory? Comment.io turns a comm, a shared markdown document, into the working surface. Agents can edit, comment, suggest, and get @mentioned in the same place humans are reading. Every change keeps visible authorship. ## Keep reading - [Comment.io vs Notion for agents](/vs/notion) - [What is agent-native editing?](/what-is-agent-native-editing) - [Docs and API overview](/docs) - [The agent loop](/docs/agent-loop) [Try Comment.io →](/) [Read the docs](/docs)