AI Council and Mem0: what each one does

In short

AI Council is a platform for development teams, cloud or self-hosted. It parses your repositories into a code graph on its own: stack, structure, dependencies and cycles, calls, data layer, architecture, DDD, patterns, style, code smells and ISO 25010 quality. On top of the graph sits the project knowledge base: decisions, notes, diagrams and changelogs. Each entry is anchored to a place in the code and to a branch, and reaches the agent when it touches that file. Conventions live separately: rules at three scopes (code entities, paths, the whole project) with MUST/SHOULD levels, states, and checks before an edit and against the diff. Around this sit review with publishing to the MR, tickets, tasks, and companies with roles and licensing. Static analysis does not use a model, but without a model that is all you get: review, knowledge review, AI chat and workspaces run through a host worker, a bridge and the vendor's CLI/OAuth. The model lives on the host, not inside the Council stack.

There are two ways to work with Council. On a developer's machine, Claude Code or Codex connects to it via MCP and hooks: project rules arrive with every message, file context on Read/Edit/Bash, and a checklist at the end of the turn. In a workspace, the task runs on a VM in an isolated sysbox container, can live for days, and a person drives it from the web UI: from analysis and diff to commit, push and MR.

Mem0 is a memory layer for AI applications and agents. It takes messages, extracts facts, preferences and procedures from them with a single LLM call, stores them in a vector store scoped by user_id/agent_id/run_id, and later searches them in hybrid mode: semantic + BM25 + entity boost. It has Python and TypeScript SDKs, two CLIs, a self-hosted FastAPI server with pgvector and a Next.js dashboard, plugins for Claude Code, Cursor, Codex, Kimi, Antigravity, OpenCode, OpenClaw, Pi and DeepSeek, and integrations with Vercel AI SDK, n8n, Zapier, Hermes and Strands. Entries can be scoped, given an expiration date, updated and deleted; procedural memory is a separate type. The hosted Platform adds things the OSS version doesn't have: a native memory graph, decay, temporal reasoning, Dream consolidation, profiles, webhooks, export, batch, app_id, organizations and projects. The OSS version explicitly rejects these features with an error. Apache-2.0.

It is a memory layer, not a code understanding layer. Mem0 stores what the agent learned about the user, the project or the work in progress; Council stores knowledge about the code anchored to positions, plus authoritative team rules. They overlap on delivering memory to the agent through hooks and MCP, and on hybrid search.

1. Understanding the code

2. Knowledge and rules

3. Requirements and tasks

4. Verification and models

5. Platform

Bottom line

Mem0 is a memory layer, not a code understanding layer. It does well something Council doesn't offer as a separate product: general-purpose memory for applications and agents, with scopes, expiration, hybrid search and ready-made plugins for nine agent hosts. Council does something else: it parses code itself and keeps knowledge anchored to code positions, authoritative conventions, review and tasks. They overlap on delivering memory to the agent through hooks and MCP and on hybrid search. They define truth differently: Council checks an entry against the code; Mem0 checks it against expiration and consolidation (on the Platform), or not at all (in OSS).

Where Mem0 is stronger:

• general-purpose memory: facts, preferences, procedures and episodes, for any application, not just code;
• scopes user_id/agent_id/run_id (plus app_id on the Platform), with metadata protected against scope spoofing;
• ADD-only extraction with a single LLM call: cheaper and faster than a two-phase approach;
• hybrid semantic + BM25 + entity boost search with explain, a threshold and an optional reranker;
• entry expiration (expiration_date), and on the Platform: decay, temporal reasoning, Dream consolidation, profiles, webhooks, export, batch;
• provider independence: 18 LLMs, 11 embedders, 25 vector stores, 5 rerankers;
• ready-made plugins for Claude Code, Cursor, Codex, Kimi, Antigravity, OpenCode, OpenClaw, Pi, DeepSeek, and integrations with Vercel AI SDK, n8n, Zapier, Hermes, Strands;
• a self-hosted server with a dashboard and API keys; Apache-2.0.

Where Council is stronger:

• Understands the code, not just memories about it. The L0–L10 graph covers stack, structure, dependencies and cycles, calls, data, architecture and forbidden dependencies, patterns, style, DDD, co-change, code smells, ISO 25010 and diagrams; static analysis doesn't call a model. Mem0 stores facts and episodes, but doesn't build a code graph.
• Knowledge anchored to a code position and a branch. An entry lives on a branch, reaches the agent when it touches the file, and goes back for re-checking when the code under it changes; the reviewer must provide a quote. Mem0 has scopes, expiration and consolidation, but no anchoring to code and no check against it.
• Conventions are authoritative, checked rules. Three scopes (entities, paths, project), MUST/SHOULD, states, checks before an edit and against the diff. Hooks deliver rules with every message and file context on Read/Edit/Bash; the KB gate blocks reading code until the agent has queried the knowledge base. Mem0 injects memories, not team rules.
• Code and knowledge review as a service. A verdict for every file, a second pass, publishing to the MR without duplicates; a separate knowledge review with quotes and calibration. Mem0 doesn't review code.
• Tasks on a VM, tickets, MRs, team. A task in a sysbox container lives for days and a person drives it from the UI: analysis, diff, commit, push, MR. Tickets, requirements tracing, companies, roles and licensing. Mem0 is a memory library and service, and doesn't have this layer.
• Shared graph across repositories and architecture history. architecture_as_of, versioned edges, SonarQube; ask_question returns excerpts with FQNs, not a model's paraphrase. Mem0 stores memory, not project architecture.
• Observability and self-healing. Telemetry for every MCP call and hook without PII, about 22 Prometheus rules, System Health, tracing; Temporal reconciliation, orphaned data cleanup, backups with restore checks. A memory library doesn't need this; a team platform does.
• Static analysis doesn't spend model tokens. Mem0 extracts memory with an LLM call. Council parses code without a model and uses a model only for review, chat and workspaces, through the host worker, bridge and vendor CLI/OAuth, not as a key inside the stack.

Can they work together? Yes, they are different layers. Mem0 stores memory about the user, the project and the session; Council stores knowledge about the code and team rules. Both work through Claude Code hooks and MCP, so they can live in the same session. They overlap on context injection at the first prompt and before tool use: Mem0 injects memories, Council injects rules and per-file knowledge. There is no built-in integration. A practical setup: Mem0 for preferences and episodes, Council as the source of truth about the code.