Shared Knowledge Layer for Agents

What is it

A Shared Knowledge Layer for Agents is the missing infrastructure between your AI agents and your team's accumulated context. Today, when you spin up a Claude Code session, a Cursor agent, or a custom LangGraph workflow, each one starts from zero — or from a siloed vector store nobody else can see. The shared knowledge layer changes that: it's a persistent, versioned store of facts, decisions, preferences, and prior conversations that every agent and every teammate can read from and write to.

The technical essence is unglamorous: plain-text files (often Markdown or JSONL) plus a sync/retrieval protocol, with embeddings layered on top for semantic search. DaiDocs' AI memory format pushes the "files over databases" philosophy — your agent's memory lives in your repo, diffable in Git, portable across tools. OzBrain takes the platform angle: one brain, many agents, many humans.

The business significance is bigger than the format war. Whoever owns the shared memory layer owns the switching cost. If your team's institutional knowledge lives in Vendor X's brain, migrating away means losing the agent's learned context. That's a sticky, defensible position — the same moat that made Notion, Figma, and Slack hard to leave.

Why now

Three forces converged in 2025-2026 to make this inevitable. First, agent proliferation. A typical engineering team now runs 3-8 distinct agents daily — coding agents, research agents, support agents — and each one re-learns the same context. The waste became visible and expensive. Second, context windows stopped being the answer. Even at 1M+ tokens, dumping everything into every prompt is slow and costly; teams want retrieval, not repetition. Third, the MCP (Model Context Protocol) standardization gave everyone a common plug shape, so a memory server can serve any compliant client instead of being locked to one IDE.

The timing signal is the source mix: a Product Hunt launch (OzBrain) and a Show HN post (DaiDocs) within the same window. That's the classic pattern of a category forming — a commercial entrant and a hacker-culture entrant independently validating the same need. A year ago, "agent memory" meant research papers on MemGPT-style architectures. A year from now, the big model providers will likely ship first-party memory as a default feature, which is why the window for an independent layer is roughly the next 12-18 months.

Policy and privacy add urgency. Enterprises increasingly refuse to let proprietary context flow into third-party model training. A self-hosted, file-based shared knowledge layer answers the compliance question that cloud-only memory products can't.

Market Evidence

The raw signal is thin but directionally clean: 2 independent sources, 2 total mentions, 100% growth rate, stage classified as nascent, trend score 66/100. Two mentions is not a market — it's a hypothesis. But the composition of those mentions matters more than the count. Product Hunt signals commercial intent (someone shipped a product and wants paying users). Show HN signals builder intent (someone published a design and wants technical critique). When both fire on the same concept in the same cycle, you're usually looking at an early category, not a one-off.

The 100% growth rate is mathematically trivial at this base — going from 1 to 2 mentions is always 100%. Treat it as a placeholder, not momentum. The honest read: this is a pre-trend. It's real enough to investigate, too early to bet a company on without primary validation.

Compare to adjacent categories at the same stage. "Vector databases" looked identical in 2020 — a handful of Show HN posts, no clear buyer. Three years later it was a multi-billion-dollar layer. "Prompt management" looked similar in 2023 and mostly got absorbed into existing platforms. The difference-maker is whether the layer accumulates proprietary data (sticky) or is a thin utility (absorbed). Shared agent memory accumulates proprietary data, which puts it in the vector-database camp — but only if you build the sync, permissions, and conflict-resolution layer, not just a file format.

Who's Behind It

Two named players anchor the early landscape. OzBrain is the platform play — "share knowledge across many agents and teammates" — positioning as the centralized brain with multi-agent and multi-human access. DaiDocs is the format play — a plain-text-file AI memory specification, betting that portability and Git-friendliness beat a hosted platform. These are opposite strategies: OzBrain wants to be the destination, DaiDocs wants to be the standard.

The real whales are one layer up. Anthropic shipped Claude memory and MCP; OpenAI has ChatGPT memory and is pushing Agents SDK; Cursor and GitHub Copilot both have workspace context features. Any of them could absorb this category as a default feature. The independent layer's survival depends on being cross-vendor — the one brain that serves Claude, GPT, Gemini, and local models simultaneously. That's a position no single model provider will ever credibly occupy, and it's the strategic ground OzBrain and DaiDocs are both implicitly claiming.

The community driving adoption is the MCP server ecosystem and the "AI-native dev tool" crowd on Hacker News — the same people who adopted Cursor, Claude Code, and local LLMs early. They're vocal, technically demanding, and allergic to lock-in, which favors the file-based approach.

TAM & Market Size

The honest buyer segmentation: (1) AI-native startups with 5-50 engineers running multiple agents — maybe 40,000-60,000 companies globally, (2) platform teams at mid-market companies (200-2,000 employees) standardizing agent workflows — another 15,000-25,000, (3) individual power users and small teams — millions, but low willingness to pay.

The paying segment is realistically 50,000-80,000 organizations. At $20-40 per seat per month with an average of 8 seats, that's $160-320 per account per month, or roughly $2,000-3,800 annual contract value. Capturing even 1% of that segment yields $100M-300M ARR ceiling — a healthy venture-scale market, but not a category where you win by default.

Price tolerance is anchored by adjacent tools: Notion AI at $10/seat, GitHub Copilot at $19-39/seat, Cursor at $20/seat. Buyers will pay $15-25/seat for a memory layer that demonstrably reduces agent re-prompting and onboarding time — but only if you can show the ROI. The opportunity and demand scores (0/100) reflect that no validated pricing data exists yet; you're pricing blind. The defensible wedge is per-agent or per-workspace pricing rather than per-seat, because agents, not humans, are the primary consumers.

Competitive Landscape

Four competitive layers, each with a different threat profile. Tier 1: model providers (Anthropic, OpenAI, Google) — they'll ship first-party memory free with the model. You cannot beat free, so you must be cross-vendor. Tier 2: agent frameworks (LangChain's LangMem, LlamaIndex, CrewAI) — they own the developer relationship but are framework-locked and weak on human collaboration. Tier 3: memory startups (Mem0, Zep, Letta) — closest competitors, mostly API-first and developer-targeted, but thin on the "teammates" half of the problem. Tier 4: knowledge tools (Notion, Obsidian, Confluence) — they own human knowledge but have no agent-native read/write protocol.

The gap is exactly where the term sits: shared between agents AND teammates. Mem0 and Zep solve agent memory; Notion solves human knowledge; nobody cleanly solves both with a portable format. That's the wedge.

The competition score of 0/100 is misleading — it likely means "insufficient data," not "no competition." Realistically you have 12-18 months before a well-funded memory startup or a model provider closes this gap. Differentiation must come from three things: portability (own your memory as files), permissions (who can read/write what across agents and humans), and conflict resolution (what happens when two agents write contradictory facts). Most competitors ignore the last two entirely — that's where you build.

Business Model

Recommendation: hybrid freemium + per-workspace SaaS, with a self-hosted enterprise tier. Freemium for individuals and small teams (up to 3 agents, 1 workspace) to drive bottom-up adoption — this mirrors how Cursor and Linear grew. Paid cloud at $19/seat/month or $149/month per workspace (whichever is higher) for teams needing sync, permissions, and audit logs. Self-hosted enterprise at $15,000-40,000/year for compliance-sensitive buyers who refuse cloud memory.

Why this fits: the value scales with team size and agent count, so per-workspace pricing captures expansion naturally. Self-hosted captures the enterprise segment that cloud-only competitors (Mem0's hosted tier, OzBrain) structurally cannot serve. The file-based format makes self-hosting genuinely easy, which turns a compliance headache into a sales advantage.

12-month forecast: Conservative — 200 paying workspaces averaging $180/month = ~$430K ARR. Base — 800 workspaces averaging $220/month plus 5 enterprise deals at $25K = ~$2.2M ARR. Optimistic — 2,500 workspaces plus 20 enterprise deals = ~$7.5M ARR. These assume bottom-up PLG motion, not outbound sales.

CAC estimate: $150-400 for self-serve (content, SEO, community), $8,000-15,000 for enterprise. Payback: 2-4 months self-serve, 6-9 months enterprise. Keep the self-serve CAC under $300 or the freemium math breaks.

MVP Blueprint

Ship in 5-7 days. Core features ONLY:

1. A memory store — a Git-backed directory of Markdown/JSONL files, one file per "memory namespace" (project, team, agent). Plain text, human-readable, diffable.
2. An MCP server — expose read_memory, write_memory, and search_memory as MCP tools so Claude Code, Cursor, and any MCP client can use it with zero integration work. This is the single highest-leverage decision: MCP gives you instant distribution across every major agent client.
3. Semantic search — embed the files with a cheap model (text-embedding-3-small), store vectors in SQLite with the sqlite-vec extension. No external vector DB needed at MVP.
4. A minimal web UI — list memories, view diffs, approve/reject agent-written entries. Human-in-the-loop approval is the trust feature that separates you from auto-writing memory tools.
5. Auth + workspaces — basic email auth, one workspace per account.

Cut: real-time collaboration, fine-grained permissions, analytics, multi-model routing, mobile. Those are month-2 features.

Tech stack: TypeScript + Node (MCP SDK is TS-first), SQLite + sqlite-vec, S3 or Git for file storage, Next.js for the UI, deploy on Fly.io or Railway. Total infra cost under $50/month at MVP scale.

Fastest path to launch: publish the MCP server to the official MCP registry and post to Show HN with a 90-second demo showing Claude Code and Cursor sharing the same memory. That single demo is the entire go-to-market.

Commercial Opportunities

Direction 1: The cross-vendor memory MCP server. Target: AI-native startups running 3+ agents. Revenue: $5K-25K MRR within 6 months from self-serve. Why it beats alternatives: it's the only position no model provider can occupy, and MCP distribution is free.

Direction 2: Enterprise self-hosted knowledge layer. Target: regulated industries (fintech, healthcare, legal) that can't send context to third-party clouds. Revenue: $20K-40K per deal, 3-8 deals in year Why it beats alternatives: compliance is a hard moat — cloud competitors literally cannot sell here.

Direction 3: The format standard + certification. Target: tool vendors who want their memory to be portable. Revenue: services, sponsorships, and a paid conformance suite. Lower revenue but highest strategic value — owning the format is owning the category. Why it beats alternatives: DaiDocs proved the format angle is live; nobody has commercialized the standard yet.

Product Ideas

🥇 AgentBrain — "One shared memory for all your agents and teammates." Target: 5-50 person AI-native startups. Value prop: point every agent (Claude Code, Cursor, custom) at one MCP endpoint and stop re-explaining your codebase and decisions. Why now: MCP is standardized, agent count per team is exploding, and no cross-vendor solution exists. This is the highest-conviction build.

🥈 MemoryDiff — "Git for agent memory." Target: teams already using file-based memory who need review, rollback, and conflict resolution. Value prop: every agent write becomes a reviewable diff; contradictory facts get flagged before they poison the context. Why now: as memory scales, silent corruption becomes the #1 failure mode, and nobody solves it. This could be a feature of AgentBrain or a standalone tool.

🥉 MemoryBench — "Measure how much your agent actually remembers." Target: developers evaluating memory tools. Value prop: standardized benchmarks showing retrieval accuracy, staleness, and cost per query across Mem0, Zep, and your own layer. Why now: the category has no neutral scoreboard, and whoever publishes the benchmark shapes buyer perception. Low direct revenue, high authority.

SEO Opportunity

Search volume for "agent memory" and "AI memory layer" is climbing steeply but still small — low thousands monthly, growing 30-50% quarter over quarter. SEO difficulty is effectively 0/100: no entrenched content, no dominant domain ranking for these terms.

Long-tail keywords to target: "shared memory for AI agents," "MCP memory server," "agent memory across Cursor and Claude Code," "plain text AI memory format," "cross-vendor agent knowledge layer."

Content strategy: publish the definitive technical comparison — "Mem0 vs Zep vs file-based memory: benchmarks and tradeoffs" — with real numbers from MemoryBench. Technical comparison posts rank fast in nascent categories and attract exactly the developer buyer you want.

Risk Assessment

Risk 1 (market): model providers absorb it. Anthropic or OpenAI ships cross-tool memory free. Mitigation: be cross-vendor and self-hostable from day one — positions they structurally can't take.

Risk 2 (tech): memory corruption and trust collapse. Two agents write contradictory facts, the shared layer poisons every downstream agent, and users lose trust permanently. Mitigation: human-in-the-loop approval and diff review from MVP, not later.

Risk 3 (execution): too early, no buyer urgency. Two mentions is a hypothesis. If teams aren't feeling the pain yet, you'll build for a market that arrives in 2028.

Cheap validation before building: run 15 customer interviews with AI-native teams asking one question — "How do you currently share context between your agents?" If fewer than 8 describe a manual, painful workaround, walk away. Also post a landing page with pricing and measure signup intent. If you can't get 50 email signups from a Show HN post, the demand isn't there yet.

Action Plan

Today: Post a landing page describing AgentBrain with pricing ($19/seat) and a waitlist. Spend $0. Simultaneously publish a technical blog post on "why file-based agent memory beats vector-only" to seed SEO.

Week 1: Run 15 customer interviews (target: AI-native startups on Hacker News and MCP Discord servers). Build the MCP server prototype — read/write/search against a local Markdown directory. Demo it with Claude Code and Cursor sharing one memory.

Month 1: Launch on Show HN and Product Hunt with the two-agent demo. Target 100 waitlist signups and 10 active beta workspaces. Ship the web UI with diff approval. Instrument everything — which agents connect, how often they read vs write.

Month 3: Convert beta to paid. Target 30 paying workspaces ($5K MRR). Publish MemoryBench v1 to establish authority. Begin enterprise conversations with 5 regulated-industry prospects.

Walk-away trigger: If by month 3 you have fewer than 10 active workspaces and no organic signups, the market is too early — shelve it and revisit in 12 months.

Related Terms

Model Context Protocol (MCP) — the standardization layer that makes a shared memory server plug into any agent client. It's the distribution channel for this entire category; without MCP, you'd need N integrations instead of one.

Agent Memory — the broader parent category covering single-agent persistence (Mem0, Zep, Letta). Shared Knowledge Layer is the multi-agent, multi-human evolution of it.

AI-Native Dev Tooling — the ecosystem (Cursor, Claude Code, Windsurf) whose users are the earliest buyers. Adoption there is the leading indicator for whether this category crosses into the mainstream.