grov — Summary

Grov is collective AI memory for engineering teams: when one developer's AI agent figures something out, every team member's agent automatically knows it. It intercepts AI API calls via a local proxy (for Claude Code/Codex) or native MCP (for Cursor/Zed/Antigravity), extracts CONCLUSION/INSIGHT reasoning traces when tasks complete, syncs them to a cloud team dashboard, and injects relevant memories into future sessions via hybrid semantic+lexical search. Beyond memory, Grov adds anti-drift detection (monitors agent actions vs stated intent and injects corrections), extended Anthropic prompt-cache warming, and auto-compaction with goal preservation. At 192 GitHub stars (Apache-2.0), it occupies a unique position as the only AI agent memory system explicitly designed for team sharing rather than individual persistence.

differs_from_seeds: Closest to ccmemory (memory-focused, cross-session injection, team awareness) but operates through a transparent proxy rather than an MCP server, targets teams rather than individuals, and stores memories in a cloud Supabase backend rather than a local Neo4j graph. Unlike ccmemory's typed graph nodes (Decision, Correction, Insight), Grov extracts untyped reasoning traces (CONCLUSION/INSIGHT pairs). The anti-drift detection and prompt-cache-warming features have no equivalent in any seed.

grov — Overview

Origin

Created by Tony Stef ("TonyStef"). Apache-2.0 licensed, actively developed as of January 2026. Free for individuals and teams up to 3 developers; team sync requires login via GitHub (grov login).

Philosophy

"When one dev's AI figures something out, every dev's AI knows it."

"Measured impact: Tasks drop from 10+ minutes to 1-2 minutes when team context is available."

The core problem Grov solves: AI agents learn the same things repeatedly. Dev A's Claude spends 10 minutes understanding the auth system. Dev B's Claude does the same exploration next day. Dev C asks a question answered last week. Every session starts from zero. Grov captures the reasoning (the WHY behind decisions), not just the facts, and makes it available team-wide.

"Your team's AI agents are learning in silos."

The secondary philosophy is that agent drift is a real problem:

"Grov monitors what Claude does (not what you ask) and corrects when it goes off-track."

Anti-Drift Vision

The anti-drift feature extracts intent from the first prompt, monitors subsequent tool calls, scores alignment 1-10 via Claude Haiku, and injects corrections at 4 levels: nudge → correct → intervene → halt. This is a novel safety primitive not present in any other memory framework.

Extended Cache Vision

"Anthropic's prompt cache expires after 5 minutes of inactivity. Grov keeps it warm."

The --extended-cache flag sends minimal keep-alive API requests during idle periods (~$0.002 each) to prevent cache recreation. This is an opt-in behavior that requires explicit consent.

grov — Architecture

Distribution

npm package (npm install -g grov). TypeScript monorepo (Turborepo) with Vitest tests.

Two Integration Modes

Mode 1: Proxy (Claude Code, Codex)

• grov proxy runs a local HTTP proxy that intercepts Anthropic API calls
• Claude Code uses the proxy via ANTHROPIC_BASE_URL environment variable
• Proxy captures full conversation, extracts memories on task completion, injects context at session start

Mode 2: Native MCP (Cursor, Zed, Antigravity)

• grov init cursor / grov init antigravity configures native MCP server
• No proxy needed; memories delivered via MCP tools
• Configured via .cursor/mcp.json or equivalent

Directory Layout

grov/
├── src/
│   ├── cli/            # CLI entry point (commander.js)
│   │   └── commands/   # init, proxy, status, sync, login, etc.
│   ├── core/
│   │   ├── extraction/ # CONCLUSION/INSIGHT reasoning extractor
│   │   ├── store/      # SQLite local storage (better-sqlite3)
│   │   └── cloud/      # Supabase team sync
│   ├── integrations/   # IDE-specific adapters
│   └── utils/
├── dashboard/          # Next.js + React 19 + Supabase web dashboard
│   └── (app.grov.dev)  # Cloud dashboard at app.grov.dev
├── api/                # Backend API (Supabase edge functions)
└── landing/            # Marketing site (grov.dev)

Storage

• Local: SQLite (via better-sqlite3) stores tasks and memories before cloud sync
• Cloud: Supabase (PostgreSQL) for team memory sharing, hybrid search (semantic + lexical)
• Sync: grov sync --enable --team <ID> enables real-time team sync

Required Runtime

• Node.js
• npm (global install)
• ANTHROPIC_API_KEY in shell profile (not just export)
• Optional: Supabase account for team sync

Target Tools

Primary: Claude Code (proxy mode). Also: Cursor, Zed, Codex, Antigravity (native MCP).

grov — Components

CLI Binary: grov

Core Systems

Web Dashboard (app.grov.dev)

Next.js + React 19 + Supabase hosted dashboard showing:

• Captured reasoning traces
• Team memory with semantic search
• Task history with files-touched
• Architectural decisions + constraints discovered

grov — Uniqueness

differs_from_seeds

Closest seed: ccmemory (persistent cross-session memory, MCP-bridged, global scope). Grov differs in: (1) cloud-first team sharing vs ccmemory's local-first individual storage; (2) transparent proxy integration rather than explicit MCP tools; (3) unstructured CONCLUSION/INSIGHT traces vs ccmemory's typed graph nodes with relationship edges; (4) anti-drift detection (novel — not in any seed) and prompt-cache warming (also novel). The proxy architecture makes Grov invisible to the agent — no tool calls needed, no hook configuration required.

Key Innovations

1. Team memory sharing — the only memory system in the corpus explicitly designed for team-wide knowledge sharing across developers
2. Anti-drift detection — monitors agent actions vs stated goal, scores alignment 1-10 via Haiku, injects corrections at 4 severity levels
3. Prompt cache warming — keeps Anthropic's 5-minute prompt cache alive during idle periods via opt-in keep-alive requests
4. Transparent proxy — no code changes, no hooks, no skill installation; just set ANTHROPIC_BASE_URL
5. Auto-compaction with goal preservation — pre-computes summary at 85% capacity, preserves goal+decisions, drops verbose exploration

Observable Failure Modes

1. Proxy dependency — ANTHROPIC_API_KEY must be set in shell profile (not just export), or proxy can't intercept calls
2. Cloud dependency — team sync requires Supabase account and internet connectivity
3. Privacy/security — reasoning traces containing sensitive code patterns are sent to Supabase cloud; enterprise users may have compliance concerns
4. Cache-warming cost — --extended-cache sends API requests on behalf of user; requires explicit opt-in consent per README
5. Alignment scoring cost — anti-drift uses Claude Haiku per agent turn; adds latency and cost to every action

Competitive Positioning

Grov is the only framework explicitly targeting the "team knowledge silo" problem. Most memory frameworks (ccmemory, planning-with-files, Continuous Claude) are individual-developer tools. Grov's closest conceptual competitor is Microsoft Copilot Work's enterprise RAG — the only competitor named in ccmemory's README.