Why 70,000 Developers
Build Claude Code Plugins
and Why Memory Is Missing
On March 31, 2026, Claude Code's source leaked through an npm sourcemap in v2.1.88, exposing 512,000 lines of internal implementation. Developers immediately began dissecting the hooks system, the agent architecture, the tool dispatch loop. The community reaction was telling: this was not outrage about a security incident. It was excitement about what the internals revealed. A platform this extensible invites builders. Over 70,000 developers are now building on top of Claude Code, and the ecosystem shows no signs of slowing. But every extension they ship has the same structural gap: it starts from zero on every run. OMEGA is the layer that closes that gap.
What the Claude Code Ecosystem Actually Looks Like
Claude Code exposes four primary extension points. Each one solves a different problem, and together they form a remarkably complete platform for building AI-native developer tooling.
The most prominent community project illustrating this ecosystem is oh-my-claudecode by Yeachan Heo. At 19,798 GitHub stars, MIT licensed, currently at v4.9.3, it packages 885 TypeScript files worth of configuration, hooks, and agent definitions into a single install. It ships 19 agents and three execution modes: standard, parallel, and orchestrated. The star count is not the interesting part. What is interesting is the architecture: it treats Claude Code as a runtime and ships a layer on top of it, like a framework for a framework.
This is exactly the kind of thing developers do when a platform is extensible enough to warrant it. The question is what the next layer looks like.
The Amnesia Problem Every Plugin Inherits
Claude Code is stateless between sessions. This is not a bug; it is a deliberate consequence of how LLMs work. Context windows fill and flush. Every new invocation of claude starts with whatever is in the current working directory, whatever CLAUDE.md files are present, and whatever the user types. Nothing more.
For simple tasks, this is fine. For building anything that compounds over time, it is a fundamental constraint. Consider what gets lost at the end of every Claude Code session:
Developers have built workarounds. CLAUDE.md files accumulate project-specific rules. Hooks inject boilerplate context. Some teams maintain handoff documents that agents are instructed to read and update. These work up to a point. At scale, they break down: CLAUDE.md becomes unwieldy, hooks inject the same stale context regardless of what is actually relevant, and handoff documents require discipline to maintain that most workflows lack.
The workarounds treat the symptom. The problem is that there is no memory layer.
OMEGA: Memory as a First-Class MCP Server
OMEGA runs as an MCP server. Claude Code connects to it via stdio, the same way it connects to any other MCP server. From Claude Code's perspective, OMEGA tools look identical to any other tool: named functions with parameters and return values.
What makes OMEGA different from a generic MCP server is what those tools do. They give Claude Code a persistent, semantically searchable store that survives across every session, every tool invocation, and every agent handoff.
{
"mcpServers": {
"omega": {
"command": "python3",
"args": ["-m", "omega", "serve"]
}
}
}That is the entire setup. Once connected, Claude Code has access to OMEGA's public tool tier: 17 MCP tools covering storage, semantic retrieval, knowledge graph operations, session coordination, and memory querying. The Pro tier exposes 116+ tools including multi-agent coordination, entity memory, and advisory functions.
What This Enables for Plugin Developers
Consider what the oh-my-claudecode architecture looks like with OMEGA in the stack. The project ships 19 agents. Each agent currently operates with the context it receives at invocation time. With OMEGA:
Local-First: Your Intelligence, Your Machine
When you build a plugin that accumulates memory over time, the question of where that memory lives matters. The sourcemap leak reminded the community that even trusted tools can expose internals unexpectedly. Memory compounds that surface area: every architectural decision stored, every codebase pattern learned, every user preference captured represents information worth protecting.
OMEGA is local-first by design. There is no API key required, no cloud account, no data leaving the machine. The storage engine is SQLite at ~/.omega/. The embedding engine is bge-small-en-v1.5 compiled to ONNX, running entirely in-process. A full OMEGA install with the embedding model is under 50MB.
$ pip install omega-memory $ omega setup # That's it. No API keys. No cloud config. # Storage: ~/.omega/omega.db (SQLite) # Embeddings: ~/.omega/models/ (ONNX, ~33MB)
The Apache-2.0 license means plugin developers can bundle OMEGA into their own tooling without restriction. The local-first architecture means the memory you accumulate is owned by the person running the tool, not by a vendor. This distinction matters more as agents become longer-running and the intelligence they accumulate becomes more valuable.
The alternative, renting memory from a cloud service, creates a dependency that compounds over time. The longer an agent runs, the more its value derives from accumulated context. If that context lives in a vendor's database, the agent's intelligence is not yours: it is theirs, licensed back to you at their pricing and their terms.
What the Leaked Sourcemap Revealed
The v2.1.88 sourcemap leak on March 31, 2026, was significant not because it exposed a vulnerability but because of what 512,000 lines of internal implementation told the community about the platform they were building on.
Developers who read the internals found confirmation of what they had been assuming: the hooks system is deeply integrated, the tool dispatch architecture is well-designed for extension, and the agent coordination logic is more sophisticated than the public documentation implied. The community response was largely constructive: better documentation requests, architectural pattern analysis, and new plugin ideas informed by the internals.
One thing the sourcemap cannot reveal, because it does not exist yet in the codebase: a native memory layer. Claude Code ships with tools for reading files, executing commands, and calling external services. It does not ship with a mechanism for accumulating knowledge across sessions. That is not an oversight. It is a boundary that MCP servers are designed to fill.
The plugin ecosystem exists because Anthropic built Claude Code to be extended. OMEGA is an extension. The install is one line.
| Capability | Claude Code (native) | Claude Code + OMEGA |
|---|---|---|
| Session memory | None (resets on exit) | Persistent across sessions |
| Cross-agent context | Context window only | Shared memory substrate |
| Knowledge retrieval | File read / grep | Semantic search (95.4% LongMemEval) |
| Decision tracking | Chat history (ephemeral) | Typed memory store (permanent) |
| Hook intelligence | Static rule injection | Dynamic context retrieval |
| Data sovereignty | Anthropic servers | Local SQLite, no cloud |
| Plugin memory | Not available | 17 MCP tools (public tier) |
Frequently Asked Questions
What is the Claude Code plugin ecosystem?
Claude Code supports extensions via slash commands, hooks, MCP servers, and agent definitions. Projects like oh-my-claudecode (19,798 stars, v4.9.3, 885 TypeScript files, 19 agents) package these into reusable configurations. Over 70,000 developers are building or using Claude Code extensions.
Why do Claude Code plugins lack persistent memory?
Claude Code is stateless between sessions. Each invocation starts from the current directory, CLAUDE.md files, and the current prompt. Hooks can inject static context, but nothing accumulates dynamically. Every session starts from zero.
How does OMEGA add memory to Claude Code?
OMEGA runs as an MCP server. Add it to your .claude.json mcpServers config. It exposes 17 tools (public tier) for storing memories, querying by semantic similarity, and coordinating across agents. Data stays in local SQLite. No API key required.
Does OMEGA work with oh-my-claudecode?
Yes. OMEGA is an MCP server, which is one of Claude Code's standard extension points. It works alongside any other hooks, slash commands, or agent definitions you have configured, including oh-my-claudecode's 19 agents.
What is the LongMemEval benchmark?
LongMemEval is a benchmark for testing memory retrieval accuracy in long-horizon tasks: recalling facts from early in a conversation, tracking user preferences, and retrieving decisions made sessions ago. OMEGA scores 95.4% on LongMemEval, using local ONNX embeddings with no cloud dependencies.
Related reading
OMEGA is free, local-first, and Apache 2.0 licensed.