Glen: Shared MCP Memory for AI Agent Teams (2026)
Glen is a free-beta MCP skill that gives every AI agent in your org shared memory. Agents call 2 tools to recall context and store new observations. YC S26.
Glen is a shared memory skill for AI agent teams, founded in 2026 and backed by Y Combinator. It connects over MCP and exposes 2 tools: recall to retrieve org observations and store to write new ones. Works with Claude Code, Cursor, and Codex. Free in closed beta. The differentiator is org-level knowledge compounding, not just per-user memory.
Glen is a 2-tool MCP skill that gives every AI agent in your organization access to a shared knowledge pool. Founded in 2026 by Nikos Dritsakos (YC S26), Glen exposes recall and store tools over the Model Context Protocol. Any MCP-compatible agent, including Claude Code, Cursor, and Codex, can use it. Currently free in closed beta.
Maker: Glen · Protocol: MCP · Auth: oauth
Compatible agents: Claude, Claude Code, Cursor, Codex, any MCP client
Required runtime: Any MCP-compatible agent host (Claude Code, Cursor, Codex, or custom framework)
About Glen
Glen is an organizational memory skill for AI agents, founded in 2026 by Nikos Dritsakos and backed by Y Combinator Summer 2026 batch. It connects to agents as a Model Context Protocol (MCP) server and exposes exactly 2 tools: recall, which surfaces the most relevant stored observations for the current task, and store, which writes new learnings back to the shared pool. Every agent across the organization reads from and writes to the same knowledge base, so expertise compounds automatically without any documentation step. Glen operates over MCP, the open standard for agent-to-tool communication. Agents add it alongside their other MCP servers in their configuration file, then call its two tools at the start and end of each turn. Authentication uses OAuth 2.1 for agent access and argon2id for API key hashing. All data lives in PostgreSQL, encrypted at rest and in transit via TLS, with row-level security enforcing org isolation at the database layer, not the application layer. Any MCP-compatible agent host works with Glen: Claude, Claude Code, Cursor, Codex, and custom agent frameworks. Because Glen is a protocol-level integration, teams do not change agent code. The benefit compounds as more agents and people participate: a senior engineer conventions stored once become every junior agent starting point from day one. Glen is currently in closed beta, onboarding teams in invitation waves at no cost. No paid tiers have been announced as of June 2026. The company is a 1-person team based in San Francisco, operating within the YC S26 program. The product launched in 2026 with a focused feature set. Development velocity is high within the YC cohort period. No public GitHub repository has been published; the codebase is proprietary.
Key Features
- Org-wide shared knowledge pool: Every agent in the organization reads from and writes to the same observation store, so no agent starts a task without the team accumulated context.
- 2-tool MCP interface: Glen exposes exactly 2 MCP tools, recall and store, in a single round-trip per turn, keeping the integration surface minimal and adding negligible latency.
- Database-level org isolation: PostgreSQL row-level security ensures one organization observations are never readable by another, enforced at the database layer rather than application code.
- OAuth 2.1 and argon2id authentication: Agent access uses OAuth 2.1 flows and API keys hashed with argon2id, with no long-lived secrets stored in agent configuration files.
- Automatic RBAC at observation level: Access control mirrors the user existing permissions at the individual observation level, so sensitive data written by a senior user is not readable by a lower-privilege agent.
- Private mode for sensitive turns: Agents can flag a turn as private so observations from confidential conversations are not written to the shared pool.
Use Cases
- Instant onboarding for new agents: When a new agent or new hire agent starts work, Glen retrieves every convention and decision the org agents have stored, cutting the time to productive output from weeks to the first session.
- Institutional knowledge retention after offboarding: When a senior employee leaves, the observations their agent wrote to Glen remain available to every future agent, so specialized domain knowledge stays in the org rather than walking out the door.
- Cross-session context for coding agents: A coding agent that learned a codebase naming conventions or test structure in one session recalls them automatically in the next, without re-reading files or asking the user again.
- Multi-agent pipeline coordination: In a pipeline where a research agent, a writing agent, and a review agent handle separate steps, each agent reads what prior agents stored so discovery work is not repeated across the chain.
Requirements
- Request waitlist access at tryglen.com (closed beta, invites sent in waves)
- An MCP-compatible agent host: Claude Code, Cursor, Codex, or a custom MCP client
- OAuth 2.1 credentials provided by Glen after account activation
Actions
Recall
Retrieves the org observations most relevant to the current agent task from the shared knowledge pool.
{
"method": "tools/call",
"params": {
"name": "recall",
"arguments": {
"context": "Reviewing a pull request for the billing service"
}
}
}context(string) — required: A plain-English description of the current task or situation. Glen uses this to retrieve the most relevant stored observations for this turn.
Store
Writes a new observation from the current agent turn into the shared org knowledge pool for future agents to recall.
{
"method": "tools/call",
"params": {
"name": "store",
"arguments": {
"observation": "The billing service requires an X-Idempotency-Key header on all Stripe API calls to prevent duplicate charges.",
"context": "Billing service code review"
}
}
}observation(string) — required: The fact, convention, or decision the agent learned this turn, written as a self-contained statement a future agent can read without extra context.context(string): Optional description of the situation in which this observation was made, used for future relevance scoring.
How to Invoke
Agents add Glen as an MCP server in their host configuration. Each turn, the agent calls the recall MCP tool with the current context to retrieve relevant org observations, and the store tool to write new learnings back. Both run in a single round trip per turn.
Pricing
Free during closed beta. No paid tiers announced as of June 2026. Teams join the waitlist at tryglen.com and are onboarded in invitation waves.
Strengths
- Zero-documentation knowledge capture: agents write observations during normal work, with no separate documentation step required.
- Protocol-level MCP integration means any MCP-compatible host (Claude Code, Cursor, Codex) works without changes to agent code.
- Row-level security at the PostgreSQL layer provides stronger org isolation than application-level access control.
Weaknesses
- Closed beta with no public install command or confirmed pricing as of June 2026; access requires a waitlist invitation.
- No published open-source code or self-hosted option: teams cannot audit or run the implementation independently.
- 1-person founding team (YC S26): early-stage product with no established long-term support track record.
Frequently Asked Questions
What is Glen and what does it do?
Glen is a shared organizational memory skill for AI agents, built over the Model Context Protocol (MCP) and backed by Y Combinator Summer 2026 batch. It was founded in 2026 by Nikos Dritsakos, previously Head of Special Projects at Composio. Glen exposes 2 MCP tools, recall and store, which agents call each turn to retrieve relevant org knowledge and write new observations back to a shared pool. The core idea is that what one agent learns, every agent in the organization keeps, without any manual documentation step. Knowledge compounds over time: an observation stored by a senior engineer agent becomes available to every junior agent from their first session. Glen is currently in closed beta, available by waitlist invitation at tryglen.com.
How do I install and set up Glen?
Glen is in closed beta as of June 2026, so setup begins by joining the waitlist at tryglen.com with a work email. The team reviews applications and sends invites in waves. Once invited, users receive OAuth 2.1 credentials to configure Glen as an MCP server in their agent host application. Agents add Glen alongside other MCP servers in their configuration file, such as the claude_desktop_config.json for Claude Desktop or the equivalent for Cursor or Codex. No public install command or npm or pip package is available yet. After configuration, agents call Glen recall tool at the start of each turn and its store tool at the end. No long-lived secrets are stored in agent config files because authentication goes through OAuth 2.1.
Which agents and LLMs support Glen?
Glen works with any agent host that supports the Model Context Protocol (MCP), the open standard introduced by Anthropic. Confirmed compatible hosts include Claude, Claude Code, Cursor, and Codex. Custom agent frameworks built on MCP client libraries also work, since Glen is a standard MCP server. Because the integration is at the protocol level, teams do not need to change agent code or use a specific SDK. The agent simply registers Glen as an MCP server in its configuration, and the two tools become callable from that point. As MCP adoption grows among agent host applications, Glen compatibility expands automatically.
How much does Glen cost?
Glen is free during its closed beta period as of June 2026. No paid tiers or pricing schedule have been announced by the company. Access requires a waitlist invitation from tryglen.com; teams do not pay to join the beta or use the service during this phase. Because Glen is a 1-person YC S26 startup, pricing decisions are likely to follow the beta period. Organizations evaluating Glen for production use should factor in the possibility of paid tiers after the beta closes. There are no usage fees, seat fees, or storage fees disclosed as of June 2026.
Is Glen open source?
Glen is not open source as of June 2026. No public GitHub repository has been published by the company. The codebase is proprietary and the service runs as a hosted platform. This means teams cannot self-host Glen, audit the source code, or submit community contributions. Organizations with strict data sovereignty requirements should note that all observations are stored on Glen infrastructure rather than on-premises. The founder has a background in tooling through prior work at Composio, but Glen itself has not announced any open-source components. Future open-source plans have not been disclosed.
What are the best alternatives to Glen?
The closest alternatives to Glen in the MCP agent memory space are Mem0, Zep, and Letta. Mem0 is a hybrid vector, graph, and key-value memory service with a free tier and a hosted API; it supports per-user and per-agent memory but focuses on individual personalization rather than org-wide compounding. Zep (also called Graphiti) builds a temporal knowledge graph and is the best pick if agents need to reason about when relationships changed over time. Letta (formerly MemGPT) is a full agent runtime with tiered memory management rather than a drop-in MCP skill. Glen differentiator against all three is its emphasis on org-level shared memory, where observations from any team member agent are immediately available to every other agent in the organization.
Who is Glen best for?
Glen is best suited for engineering teams that run multiple AI coding agents such as Claude Code or Cursor on a shared codebase, where accumulated knowledge about conventions and patterns matters. It is also a strong fit for operations teams where multiple employees use agents for the same recurring workflows, and for organizations concerned about losing institutional knowledge when experienced employees leave. AI platform engineers building multi-agent pipelines benefit from Glen as a ready-made shared state layer that avoids custom memory infrastructure. Glen is not well suited for teams that need a self-hosted, auditable, or open-source memory layer, or for individual developers who only need per-session memory without org-wide sharing.
How does Glen compare to Mem0 in 2026?
Glen and Mem0 both provide persistent memory for AI agents over MCP, but they serve different scopes. Glen targets organizational memory: observations are shared across every agent and team member in the org, so the system compounds over time as more people contribute. Mem0 focuses on per-user and per-agent personalization, storing preferences and past interactions for a single user or session rather than an entire team. Mem0 offers a public API, a free tier with defined limits, and a mature hosted plan; Glen is in closed beta with no published pricing. Mem0 has a published open-source SDK; Glen codebase is proprietary. Pick Glen if your priority is org-level knowledge sharing with automatic audit trails. Pick Mem0 if you need production-ready per-user memory with a paid SLA and open-source optionality.