Convergence Radar Convergence Engine

← Feed

C

TeamMem: shared/private memory sync (MCP server) for Claude Code teams

46/100

A hosted MCP memory server that lets small teams running Claude Code share a versioned team-context store while keeping private context partitioned β€” sold as $15-30/seat micro-SaaS to agent-heavy dev teams.

Interesting but not urgent. Β· created 2026-07-10 03:03 UTC

aisaasapiagentrevisit later

Scorecard

newness 6/10
convergence 5/10
demand evidence 3/10
existing spend 1/10
solo feasibility 9/10
speed to mvp 9/10
speed to revenue 4/10
distribution 6/10
competitive gap 3/10
expansion 6/10
founder fit 5/10

Penalty flags
long trust cycle platform policy risk (βˆ’7 from raw 52)

Opportunity brief

What changed
FACT: A team founder publicly described (Ask HN) that two cofounders each run local Claude Code agents whose accumulated context (strategy, customer notes, decisions) is trapped per-machine and drifting, with only hacky workarounds like a shared Google Drive folder (https://news.ycombinator.com/item?id=48848840). FACT: The Claude Code ecosystem is expanding beyond Anthropic's API β€” Ollama now exposes Anthropic-API-compatible endpoints so Claude Code works with local models (https://ollama.com/blog/claude). FACT: Google is moving agent plumbing (background tasks, remote MCP) into the managed Gemini API (https://blog.google/innovation-and-ai/technology/developers-tools/expanding-managed-agents-gemini-api/), signaling providers absorbing agent infrastructure.
Why now
Claude Code adoption is growing fast and multi-person teams are hitting the memory-silo wall now; MCP is a stable, documented integration surface, so a remote memory MCP server is a small, well-scoped build today. HYPOTHESIS: the window is short β€” provider-hosted agent infra (as Gemini's managed-agents move shows) suggests Anthropic may ship native team memory, which would crush a thin third-party layer.
Converging signals
(1) PAIN: concrete team-agent-memory complaint with sync conflicts, no history, no shared/private boundary (HN 48848840). (2) Ecosystem breadth: Claude Code now runs against local models via Anthropic-compatible APIs, widening the user base a backend-agnostic memory layer could serve (ollama.com/blog/claude). (3) Platform direction: providers are hosting agent orchestration and remote MCP natively (Google blog), which both validates remote-MCP architecture and threatens third-party middleware.
Customer pain
FACT (single source): cofounders each accumulate agent context locally; it drifts, conflicts, has no history, and there is no way to share a subset while keeping private notes separate; current workaround is a Google Drive folder (HN 48848840). HYPOTHESIS: this pain generalizes to many 2-10 person Claude Code teams β€” plausible but NOT proven by the supplied evidence; there is exactly one complaint and zero hiring/spend signals in demand_evidence.
Who pays
HYPOTHESIS: technical founders and small dev teams (2-10 seats) already paying $100-200/mo/person for Claude Max β€” they have budget and card-on-file behavior. No FORCED BUYER exists; no hiring/spend evidence was provided, so willingness to pay is unproven. Developers in this segment habitually expect memory MCP servers to be free/open-source, which is the core monetization risk.
Solved today
FACT: shared Google Drive folder of markdown context files (cited in HN thread). Also (general knowledge, not from supplied sources): checked-in CLAUDE.md files, git repos of notes, and open-source memory MCP servers (Anthropic's reference memory server, mem0/OpenMemory, Letta, Zep) that are single-user-oriented.
Why current solutions are bad
FACT (from HN post): sync conflicts, no version history, no shared-vs-private partition, silent drift between machines. Git-based sharing forces all-or-nothing sharing and manual merges; existing memory MCP servers are mostly single-user local stores without team ACLs or conflict resolution.
Proposed product
A remote MCP memory server: Postgres-backed store with (a) team namespace + per-user private namespace, (b) versioned entries with history/rollback, (c) last-write-wins + human-readable diff review for conflicts, (d) selective share command ('promote this memory to team'), (e) works with any Anthropic-API-compatible client including local-model setups. Ship an open-source self-host core + hosted sync as the paid tier.
MVP version
1-2 weeks solo: FastAPI + Postgres remote MCP server exposing memory_read/memory_write/memory_promote/memory_history tools, API-key auth per user, team/private partitions, simple web viewer. Charles already runs FastAPI+Postgres+MCP-adjacent infrastructure (the Convergence stack), so this is squarely in-stack. Dogfood on his own multi-agent setup immediately.
30-day build
Week 1-2 build MVP; week 2 answer the HN thread with a working demo and post 'Show HN'; list on MCP directories (mcp.so, Smithery, PulseMCP); recruit 10-20 free design partners from HN/r/ClaudeAI/Discord; instrument which features (history, private partition, promote) get used.
60-day build
Add hosted tier with Stripe ($15/seat/mo, team plan $49/mo up to 5 seats); add conflict-diff UI and encrypted-at-rest option (teams will worry about strategy/customer notes in a third-party store); convert 3-5 design-partner teams to paid; publish 'how we share Claude Code memory across a team' content targeting the exact search/complaint language.
90-day revenue plan
Target: 10-20 paying teams β‰ˆ $500-1,500 MRR. HYPOTHESIS β€” that is a modest ceiling and it is NOT cash-in-30-days; realistic first revenue is day 45-60. If <5 teams pay by day 75, kill and open-source fully for reputation.
Distribution path
Direct answer in the originating HN thread, Show HN, MCP server directories, r/ClaudeAI and Claude Discord, SEO on 'share Claude Code context across team'. No enterprise sales needed; self-serve. Weakness: discovery depends on Anthropic-ecosystem channels he doesn't control.
Pricing hypothesis
Free self-host/single-user; $15/seat/mo hosted sync or $49/mo team-of-5; annual discount. Per-seat because value scales with team size. HYPOTHESIS: dev willingness to pay for memory infra is unproven; open-source alternatives cap pricing power.
Technical difficulty
Low-moderate for MVP (CRUD + auth + MCP protocol + versioning). Real difficulty is in trust (holding other companies' strategy notes) and in conflict-resolution UX β€” merge semantics for free-text memory are genuinely hard to do better than 'last write wins + history'.
Legal / regulatory risk
Low regulatory risk, but the product stores customers' confidential business context β€” a breach is existential for trust. Needs clear DPA-lite terms and encryption; no licenses/permits involved.
Platform dependency
HIGH and this is the main kill risk: the product exists only inside the Claude Code/MCP ecosystem, and Anthropic shipping native team/shared memory (plausible given the provider trend shown by Gemini's managed agents) would erase the standalone value overnight. Mitigation: backend-agnostic MCP works with any client (including Ollama-backed setups), but the buyer pool is still Anthropic-centric.
Founder fit
Moderate. Fits Charles's stack (Python/FastAPI/Postgres, MCP, AI workflows, fast prototyping, demonstrated-value selling, no enterprise sales) and he is a heavy Claude Code user who can dogfood. BUT it is NOT his proven regulatory-filing shape: there is no mandate, no forced filer, no per-transaction toll booth β€” so his strongest, demonstrated edge (FMCSA ELDT-style government-portal monetization) is unused here.
Breakout potential
If MCP memory becomes standard team infra, this could grow into the 'shared brain' layer for all agent tooling (cursor/Gemini CLI/local models) β€” real but speculative upside; more likely outcome is a niche $1-3k MRR tool or acqui-absorption by platform features.
Final recommendation
CONDITIONAL PASS β€” do not commit the 90-day cash plan to this. The pain is real but proven at n=1, spend is unproven, and platform risk is severe. Worth a strictly time-boxed 2-week experiment ONLY because the MVP is nearly free for Charles to build on his existing stack: build, answer the HN thread, and demand 5 teams that will pay within 30 days of the demo. If that bar isn't met, open-source it for reputation and redirect to a forced-buyer (government-mandate) opportunity, which is his proven, higher-fit shape.
Next action
Reply to HN thread 48848840 (and DM the poster) with a concrete offer: 'I'll build the shared/private MCP memory sync β€” will you pay $49/mo for it?' Pre-sell 5 teams before writing more than the 2-week MVP.

Kill arguments (adversarial)

Competitors

β€’ Anthropic reference 'memory' MCP server (link) β€” Free official knowledge-graph memory MCP server; single-user but trivially forkable toward teams β€” anchors price at $0.
β€’ mem0 / OpenMemory MCP (link) β€” VC-backed memory layer for AI agents with an MCP server; already moving toward cross-app shared memory.
β€’ Letta (MemGPT) (link) β€” Agent memory platform with persistent server-side memory; heavier but overlapping.
β€’ Zep (link) β€” Temporal knowledge-graph memory for agents; developer-focused, hosted, funded.
β€’ Git-committed CLAUDE.md / shared-drive folders (link) β€” The real competitor: free hacky workarounds the HN poster already uses.

Source citations (facts)

β€’ [PAIN] Ask HN: How do you share agent context across a team? β€” Two cofounders running local Claude Code agents have per-machine context that drifts, conflicts, lacks history and lacks a shared/private boundary; current workaround is a Google Drive folder. Sole direct demand evidence (PAIN type; no hiring/spend or forced-buyer evidence supplied).
β€’ Claude Code with Anthropic API compatibility β€” Claude Code and other Anthropic-API clients can run against local open models, widening the addressable client base for a backend-agnostic MCP memory server.
β€’ Expanding Managed Agents in Gemini API: background tasks, remote MCP and more β€” Providers are absorbing agent orchestration (background tasks, remote MCP) into managed APIs β€” validates remote-MCP architecture while signaling platform risk that first-party team memory gets built in (scope inference from headline-level source).

Actions