AI Council vs Claude Context: 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.

Claude Context is an MCP plugin for semantic code search for AI agents (Claude Code, Cursor, Gemini CLI and others). The codebase is split into chunks, each chunk is embedded as a vector and stored in Milvus/Zilliz Cloud. The query is embedded too and searched in hybrid mode: dense vectors plus BM25 (sparse) with RRF reranking. Instead of whole directories, the agent gets a few relevant snippets with path, lines and score. It has incremental background sync via a Merkle DAG, a state snapshot, four MCP tools, and VS Code and Chrome extensions. MIT license.

It is a pure RAG tool: fast code search that saves tokens. Claude Context doesn't keep a graph, knowledge, rules, review or tasks. It is a search layer, and Council complements it with code understanding, knowledge and rules.

1. Understanding the code

	AI Council	Claude Context
What gets built	Council itself parses the repositories and builds the graph. No model is called during analysis	A chunk index: AST chunking (tree-sitter) plus embeddings in Milvus/Zilliz. No graph or layers
When	On project creation, on push to main (polling), on demand, and nightly; after the agent edits a file, the file and its dependents are recomputed	When `index_codebase` is called; then background sync every 5 minutes or on the `~/.context/.sync-trigger` trigger; incremental via Merkle DAG
What it extracts	Layers L0–L10: stack, structure, dependencies and cycles, metrics and calls, data (ORM, DDL), architecture and forbidden dependencies, patterns, style, DDD, files that change together, code smells, ISO 25010 quality, diagrams	Code chunks with path, line range, language and similarity score. No architecture, layers, DDD, code smells or quality
Precision	A graph from static analysis: broad, but approximate where type inference is needed	Search by semantic similarity, not by symbol: references, implementations and declarations are not resolved; quality depends on chunking and the embedding model
Languages	Python, PHP, TypeScript, JavaScript, Java, Kotlin, C#, C, C++, with full layer analysis	AST chunking for 9 languages (JS, TS, Python, Java, C/C++, Go, Rust, C#, Scala); the rest fall back to LangChain. The list of indexed extensions is wider: Markdown, ipynb, Ruby, Swift, Kotlin, PHP and others
Multiple repositories	A project made of several repositories with a shared graph	One collection per absolute path: `hybrid_code_chunks_<md5(path)[0:8]>`. A symlink or a second clone is a separate index; no shared graph
External analyzers	SonarQube: imports its findings; its own scanner (text-based languages, JVM, .NET, .NET Framework on Windows)	—
History	Edges are versioned after every run; `architecture_as_of` shows the architecture as of a date	No history, only a Merkle snapshot of file hashes for incremental sync
Search	Semantic and regex search, `find_usages`, `find_path`, dependency graph, similar implementations; `ask_question` returns excerpts from the knowledge base without a model's paraphrase	Hybrid search: dense + BM25, RRF k=100, deduplication of snippets with more than 50% line overlap. No graph queries and no semantic search over knowledge

2. Knowledge and rules

	AI Council	Claude Context
Knowledge base	Decisions, notes, Mermaid diagrams, changelogs. Each entry is anchored to code and reaches the agent when it touches that file	No separate knowledge base, only code chunks and their vectors. It doesn't store decisions, rationale or team rules
Freshness	An entry holds its place in the code on its branch and goes back for re-checking when the code under it changes, the entry itself changes, a similar entry appears, or the branch is merged. The reviewer must provide a quote; the outcome is a label	The index updates incrementally via Merkle DAG (added/removed/modified); there is no knowledge to check. Chunk staleness is tracked only by file hash
Branches	Knowledge and the graph are stored per branch; the agent sees its own branch, the parent and whatever was merged; on merge, entries move with the code	The index is tied to a path, not a branch; a branch switch is picked up by the sync through file hashes, but there is no per-branch knowledge
Rules	Conventions at three scopes: code entities, paths (they apply even to a file that doesn't exist yet), the whole project. MUST/SHOULD, draft, retired and deleted states. Checked before an edit and against the diff	Only file inclusion rules: `.gitignore`, `.contextignore`, `~/.context/.contextignore`, default ignores and hidden segments. No team rules, conventions or diff checks
How it reaches the agent	Claude Code hooks: project rules with every message, a wide channel before an action, file context on Read/Edit/Bash, a checklist at the end; the KB gate	Pull only: the agent calls `search_code` itself. Background sync keeps the index fresh but delivers nothing unasked. No hooks or gates
MCP	Server: about 60 tools, profiles, modes, XML with a size budget	Server: 4 tools, `index_codebase`, `search_code`, `clear_index`, `get_indexing_status`; stdio
Moving knowledge	Bulk export and import of knowledge, copying between projects	No knowledge to move; the index lives in Milvus, state in `~/.context/mcp-codebase-snapshot.json` and `~/.context/merkle/`

3. Requirements and tasks

	AI Council	Claude Context
Requirements	Traces tests to requirements by tags: coverage and gaps; "no test" is a tri-state, not requirements management	—
Tickets	Jira, GitHub Issues, Redmine: reading, parsing into knowledge, graph-based advice per ticket	—
Working on your own machine	The agent is the developer's Claude Code or Codex; Council supplies context and rules via MCP and hooks; local diff review, diff walkthrough, diff check against rules	This is its main mode: an MCP plugin for Claude Code, Cursor, Gemini CLI and others; the `Context` library plus an embedding model plus Milvus for your own integrations
Workspace	Tasks on a VM in a sysbox container, living for days; a person drives them from chat; a mentor agent; diff, commit, push, MR	No tasks or workspace: code search only
PR	Review with publishing to the MR (GitHub, GitLab, Bitbucket)	—
Process	A task state machine: created, analysis, in progress, MR, closed; a person defines what happens at each step	No task process. `evaluation` is a search benchmark, not a workflow

4. Verification and models

	AI Council	Claude Context
Code review	A separate service: looks at what changed, a verdict for every file, a second pass, publishing to the MR without duplicates	No AI review. There is `evaluation`, a benchmark comparing grep-only with grep + Claude Context on SWE-bench Verified
Models	A model is required: on the host, two processes use the vendor's OAuth: AI chat and six background jobs (review, knowledge review, ticket parsing and others). Without a model, only static code analysis remains	No LLM of its own. It needs an embedding provider: OpenAI (default `text-embedding-3-small`), VoyageAI, Gemini, Ollama or OpenRouter. In Council, embeddings are an internal layer (vector-service)
Agents	Claude Code and Codex (hooks, MCP); MCP is open to any client	Client-agnostic MCP: Claude Code, Cursor, Gemini CLI and others; plus VS Code and Chrome extensions
Measurement	Telemetry for every MCP call and hook; an agent repeating a search signals a poor first answer	The `evaluation` benchmark: 30 SWE-bench Verified tasks, GPT-4o-mini, 3 runs; F1 0.40 vs 0.40, tokens −39.4%, tool calls −36.3%. Note: the edit server is a stub, so it measures file identification, not patch correctness
Risks	SSRF protection, RBAC, task isolation, read-only knowledge reviewer	Keys stored in plain text (`~/.context/.env`, VS Code settings, `chrome.storage.sync`); MCP without authentication (stdio); the Chrome extension inserts paths into `innerHTML` without escaping; the VS Code AST stub loads wasm from a CDN at `@latest`

5. Platform

	AI Council	Claude Context
Users	Companies, members, roles (can be scoped to a project), permissions. Company API keys. Data is separated: a request without a company is rejected. License and seat limits	One user, local. No multi-user model, roles or license
Interface	About 50 pages: code, graph, branches, quality, rules, review, knowledge, tickets, tasks, MCP Live, administration, System Health	Four MCP tools, a VS Code extension (`semanticcodesearch`: commands, webview, auto-sync), a Chrome extension (GitHub Code Vector Search), a library
Monitoring	Telemetry for every MCP call and hook without PII; about 22 Prometheus rules with tests; System Health, tracing	Logs to stderr, status via `get_indexing_status`, a state snapshot, a Merkle snapshot. No Prometheus or System Health
Self-healing	Reconciles Temporal with the database, cleans up orphaned data, deletes projects in batches, nightly backup with restore check, telemetry retention	Restores the snapshot from the cloud, repairs 0/0 records, cross-process sync lock, re-indexes changed files. No backup or restore check
Storage	Neo4j, Qdrant, PostgreSQL per service, Temporal, NATS, Redis	Milvus/Zilliz Cloud (one collection per codebase) plus files in `~/.context`: snapshot, Merkle snapshots, `.env`, lock
Isolation	A sysbox container per task, one-time credentials for push, read-only knowledge reviewer, permission checks in a single gateway, SSRF protection	Local stdio MCP without authentication; keys in plain text; broad host permissions in the Chrome extension; no sandbox
Delivery	A distribution for self-hosted installation, or SaaS; on the developer's machine, MCP and hooks	npm packages `@zilliz/claude-context-core` and `@zilliz/claude-context-mcp`, VS Code and Chrome extensions; CI builds but doesn't run tests; package versions are out of sync
License	Proprietary	MIT

Bottom line

Claude Context is pure RAG: search, not understanding. It gives the agent fast hybrid code search and saves tokens, but it doesn't build a graph, keep knowledge or rules, review code or run tasks. Council is the opposite: graph, knowledge, rules, review, tasks, team. They complement each other: Claude Context can be the fast search layer, and Council the layer for understanding, knowledge and rules.

Where Claude Context is stronger:

hybrid dense + BM25 search with RRF and AST chunking;
incremental sync via Merkle DAG and background index updates;
a simple MCP server with four tools;
client-agnostic: Claude Code, Cursor, Gemini CLI; VS Code and Chrome extensions;
a measured effect: fewer tokens and tool calls at the same F1;
open source under MIT, installs from npm.

Where Council is stronger:

Understands the project, not just finds snippets. 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. Claude Context gives fast search over AST chunks; Council adds relationships, architecture and quality, and its static analysis doesn't call a model.
Knowledge anchored to code and branches, not to an index path. 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. Claude Context's index is tied to a path and doesn't know about branches; it holds no knowledge about decisions and rationale.
Conventions are checked, not just added to the context. Three scopes: entities, paths (including files that don't exist yet), 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. Claude Context is a search layer with no 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. Claude Context doesn't review or publish findings.
Tasks on a VM, tickets, MRs, team. A task lives in a sysbox container for days and a person drives it from the UI: analysis, diff, commit, push, MR. Jira/GitHub/Redmine tickets, tracing tests to requirements, companies, roles and licensing. A search MCP server doesn't have this platform layer.
Shared graph across repositories, architecture history, SonarQube. architecture_as_of, versioned edges, an external analyzer. Claude Context indexes one path and doesn't model 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 search layer doesn't need this; a team platform does.
Embeddings are an internal layer. You don't need to connect an embedding provider. A model is still needed for review, chat and workspaces; it lives on the host through the worker, bridge and vendor CLI/OAuth, not as a key inside the stack.

Can they work together? Yes, they are different layers: Claude Context finds snippets by meaning, Council provides the graph, knowledge, rules and review. Both are MCP servers, and one agent can connect to both. They overlap on code search: Council has semantic search, regex and graph queries; Claude Context has hybrid search with AST chunking. Claude Context is faster and cheaper for "find something similar"; Council covers more for "show the relationships and explain why". There is no built-in integration: Claude Context's index is tied to a path and doesn't know about branches, while Council's knowledge does.

AI Council and Claude Context: what each one does