Why not coordinate agents through the message history alone?

Passing all shared state through messages bloats every prompt and loses everything when the run ends. Glen holds the shared knowledge in durable, org-scoped memory that every agent reads and writes, so coordination does not depend on ever-larger prompts.

Can agents from different frameworks share one memory?

Yes. Glen is a standard MCP server, so a multi-agent system spanning LangGraph, CrewAI, custom agents, and other frameworks all read and write the same shared store through one tool.

Shared memory for multi-agent systems

In a multi-agent system, the hardest problem is rarely orchestration, it is shared state. You have a planner, specialists, a critic, maybe dozens of agents collaborating, and they need a common picture of what is true. Passing everything through the message bus bloats every prompt and still loses the knowledge the moment the run ends; giving each agent its own memory guarantees they drift, duplicate work, and contradict one another. The handoffs between agents are exactly where context leaks. Glen, shared memory for AI agents, gives the whole system one memory every agent reads from and writes to, so coordination happens through shared knowledge instead of ever-growing prompts.

Connect Glen to every agent in your system over MCP and each gains a single tool that retrieves the shared context and records new facts in one round trip. A planner can write what it decided; a specialist downstream reads that decision instead of receiving it stuffed into its prompt; a critic records what failed so the next agent does not repeat it. The shared store becomes the system's common ground, and because reading and writing are one call, agents stay coordinated without you hand-wiring state through every edge and handoff.

This is the part per-agent memory cannot do. Glen's memory is org-scoped and shared, so it is not one agent's private notebook but the system's collective knowledge, and it persists beyond a single run. A fact one agent records survives into the next run and is available to agents added later, even ones built on different frameworks, because Glen is a standard MCP server rather than a framework-internal feature. That means a system spanning LangGraph, CrewAI, and custom agents can still share one source of truth. The knowledge compounds across runs instead of being rebuilt from the message history every time. Connect once over OAuth or an API key and let the shared memory carry the coordination your prompts no longer have to.

FAQ

Why not coordinate agents through the message history alone?: Passing all shared state through messages bloats every prompt and loses everything when the run ends. Glen holds the shared knowledge in durable, org-scoped memory that every agent reads and writes, so coordination does not depend on ever-larger prompts.
Can agents from different frameworks share one memory?: Yes. Glen is a standard MCP server, so a multi-agent system spanning LangGraph, CrewAI, custom agents, and other frameworks all read and write the same shared store through one tool.