Glen review, pricing and limits

Glen is a shared memory layer for AI agent teams, founded 2026 and backed by Y Combinator S26. Originally a 2-tool MCP skill (recall and store), it now also ingests Slack, GitHub PRs, tickets, docs and calls, plus a web app and PR reviewer. Vendor evals report roughly 29% lower token spend. Free in closed beta, waitlist only.

Glen expanded in 2026 from a 2-tool MCP skill into a full organizational learning layer: it now captures agent sessions, Slack messages, GitHub pull requests, tickets, docs and calls, then feeds context back into every agent's prompt. A web app and Slack bot let any employee query the shared pool directly. Still free during closed beta, backed by Y Combinator.

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's 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's 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's 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.
• Multi-source capture beyond agent sessions: Glen ingests Slack threads, code-review activity, support queues and internal documentation alongside agent turns, so shared context exists for work an agent never touched directly.
• Company brain web app, Slack bot and PR reviewer: Beyond the MCP recall and store calls, Glen ships a web app and Slack bot so any employee can query the shared knowledge pool directly, plus a PR reviewer that traces why a change was made, not just what changed.

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

Glen stays free while it is in closed beta (checked September 2026); no paid tiers or schedule have been published yet. 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.
• Captures context from Slack, GitHub, tickets and docs automatically, not just agent sessions, so knowledge exists even before an agent works on something.

Weaknesses

• Closed beta with no public install command or confirmed pricing as of September 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 backed by Y Combinator: early-stage product with no established long-term support track record.

View the official Glen skill page