Introducing Glen

Today we are introducing Glen, a shared memory layer for the AI agents your organization already runs. Every agent reads from and writes to one place, so what any agent learns becomes available to all of them. Knowledge compounds across your company instead of resetting at the end of each session.

The problem we started with

Agents have gotten good at the work. What they are missing is memory. Every session starts from zero, so an agent forgets the convention it was taught yesterday, the decision the team made last week, and the way your company actually does things. The memory tools that exist today hand each agent its own private notebook, which means even when one agent works something out, the agent at the next desk never hears about it. You end up with a row of capable strangers, each one solving the same problem on its own.

What Glen does

Glen sits behind a single endpoint your agents call. On every turn it does two things at once:

• Recall. It reads the conversation so far and returns the handful of facts from your organization's memory that matter for what the agent is doing right now, and nothing it does not need.
• Remember. In the same round trip, it pulls the new things worth keeping out of that conversation and writes them back, so the next agent starts ahead of where this one did.

That is the whole loop. The agent asks, Glen answers with what the organization already knows, and the organization learns a little more from the exchange. No one has to stop and write documentation for it to happen.

One memory, every agent

The word that matters is shared. Memory in Glen belongs to the organization, not to a single user or a single thread. When every agent draws from the same understanding, the walls between roles start to soften. A new hire's agent opens to the company's accumulated context on day one instead of a blank page. Two agents working in parallel stop contradicting each other, because they are reading the same facts. Work stops being redone, because the organization remembers it was already done.

How it works in practice

Glen is a remote server that speaks the Model Context Protocol, the same protocol your tools already use. You point an MCP client at the endpoint, authorize it once, and the memory tools appear.

# Any MCP client (Claude Code, Cursor, an internal copilot)
glen  ->  https://<your-org>.glen.app/mcp     auth: OAuth 2.1

There is no SDK to vendor into each agent and no database to wire up. The memory lives in front of all of your agents rather than inside any one of them, which is exactly why it can be shared.

Why it compounds

A memory that everyone writes to and everyone reads from gets more valuable the longer you run on it. Every conversation adds a little. Every new agent inherits everything that came before. The company that has been running on Glen for a year is not using the same product as the company that started yesterday, because the first one has a year of its own context behind every answer.

This is the first piece of something larger. If your company runs agents, we would like to give yours a memory.

Two reads if you want the longer version: our thesis on why memory should be organizational, and the problem with today's memory solutions.