Made on
Tilda
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.
CodeGraph is a local-first code understanding layer for AI agents. It parses the repository with tree-sitter (wasm or a native Rust kernel), stores symbols and relationships in a per-project SQLite database with FTS5, resolves references with a heuristic resolver, and exposes the graph to the agent through a single MCP tool, codegraph_explore. It has a CLI, a Claude Code prompt hook, an installer for 11 agent hosts, a file watcher, git hooks and an unreleased browser viewer. Extraction and resolution are deterministic, no LLM is used anywhere, and no provider keys are needed. MIT.
Among local tools, it is the closest to Council's code understanding layer, and it also shows a different delivery philosophy: instead of about 60 MCP tools and hooks with a gate, one tool that aims to be complete enough that the agent stops reading files. But CodeGraph doesn't keep knowledge, conventions, review or tasks. It is a graph of symbols and flows, not a team platform.
| AI Council | CodeGraph | |
|---|---|---|
| Who reads the code | Council itself: it parses the repositories and builds the graph. No model is called during analysis | CodeGraph itself: tree-sitter (wasm) or the native Rust kernel extracts symbols, then a heuristic resolver turns references into edges. No model is called at any step |
| 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 | On codegraph init/index, then incremental sync; the watcher picks up edits in about a second, and post-commit/post-merge/post-checkout git hooks run sync in the background. No server-side schedule or nightly analysis |
| 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 | A typed graph: 23 node kinds (file, class, function, method, route, component, …) and 13 edge kinds (contains, calls, imports, extends, implements, navigates, …). Plus derived data: flow across named symbols, dead code, type hierarchy, call guard conditions, 36 framework resolvers and 43 synthesis passes. No architecture, DDD, patterns, style, code smells, ISO 25010 or architecture diagrams |
| Languages | Python, PHP, TypeScript, JavaScript, Java, Kotlin, C#, C, C++, with full layer analysis | 42 languages in LANGUAGES; 20 are routed to the native kernel (TS/TSX/JS/JSX, Java, Python, Go, C, C++, Rust, C#, Ruby, PHP, Swift, Kotlin, R, Lua, Luau, Scala, Dart), the rest go through 29 wasm grammars with per-file fallback. Depth: symbols and relationships, without layers or metrics |
| Multiple repositories | A project made of several repositories with a shared graph | One project root and one SQLite database in .codegraph/; monorepos via subprojects and projectPath, but no shared graph across repositories |
| History | Edges are versioned after every run; architecture_as_of shows the architecture as of a date | No history: the index reflects the current working tree. sync compares the file system with the index, not git history; past edges are not kept |
| 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 | Lexical search: FTS5 with BM25 weights, then LIKE, fuzzy Levenshtein and exact name. Plus path pins and name_segment_vocab for camelCase. No semantic or vector search; codegraph_explore is one query that gathers source, flow and blast radius within about 24K characters |
| AI Council | CodeGraph | |
|---|---|---|
| Knowledge base | Decisions, notes, Mermaid diagrams, changelogs. Each entry is anchored to code and reaches the agent when it touches that file | No knowledge base. The graph is a derived structure of the code, not knowledge about decisions, rationale or agreements. docs/ and the docs site are project documentation, not a queryable knowledge base |
| 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 | Freshness of the index, not of knowledge: the watcher, pending-file banners, a content-hash check on responses (a file that changed on disk isn't sliced by old line numbers), IndexHealth. There are no entries to check against the code |
| 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 working tree is indexed; a worktree created inside the main checkout is detected so it doesn't answer from another index. No per-branch knowledge or graph versions |
| 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 | No conventions engine. codegraph.json (extensions, include/exclude/ignore, deprioritize) defines the indexing scope, not code rules. The installer writes an instruction block for the agent into CLAUDE.md/AGENTS.md/GEMINI.md, but it isn't checked against the diff |
| 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 | The codegraph_explore MCP tool and a Claude Code UserPromptSubmit prompt hook. HIGH: a structural key or code token confirmed by the index triggers a full explore. MEDIUM: prompt words match name segments, giving a short list of symbols. Otherwise a silent no-op. The hook fails open and never breaks the prompt. No KB gate |
| MCP | Server: about 60 tools, profiles, modes, XML with a size budget | Server: one tool by default, codegraph_explore. The others (node, search, callers, callees, impact, files, status) are defined and work, but aren't listed to the agent unless enabled via CODEGRAPH_MCP_TOOLS. The CLI returns the same answers for people and non-MCP hosts |
| Moving knowledge | Bulk export and import of knowledge, copying between projects | The index lives in the project's .codegraph/; no knowledge export as a bundle. The installer only carries over MCP server config and a short instruction block |
| AI Council | CodeGraph | |
|---|---|---|
| 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 only mode: CLI, MCP server, prompt hook, watcher, git hooks, an installer for 11 hosts (Claude Code, Cursor, Codex, opencode, Hermes, Gemini, Antigravity, Kiro, Copilot VS Code/CLI/JetBrains) |
| 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: just the project index and answers to queries |
| 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. There is an index lifecycle: init, index, sync, watcher/git hook. The pending/failed states on unresolved references are memory for the incremental pipeline, not a task |
| AI Council | CodeGraph | |
|---|---|---|
| Code review | A separate service: looks at what changed, a verdict for every file, a second pass, publishing to the MR without duplicates; knowledge review is separate | No AI review. The graph provides inputs for review (flow, blast radius, dead code, guard conditions), but there is no verdict, second pass or publishing to the PR |
| 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 at all: extraction, resolution and search never call a model; no provider keys and no embeddings. Analysis is fully local and deterministic |
| Agents | Claude Code and Codex (hooks, MCP); MCP is open to any client | MCP clients and 11 agent hosts via the installer; a Claude Code prompt hook; CLI. No agent runtime of its own |
| Measurement | Telemetry for every MCP call and hook; an agent repeating a search signals a poor first answer | 765 test files, about 208k lines; real SQLite and files, no DB mocks; parity tests of the Rust kernel against wasm; an agent-eval A/B on 7 repositories: −35% cost, −57% tokens, −46% time, −71% tool calls (median of 4 runs). The target is 1 explore call on a small repository and 3–5 on a large one, with Read/Grep = 0. Council's analysis of the CodeGraph codebase: maintainability 0.82; 4 of 7 fitness functions pass (no cycles, no layer violations, type hints 0.97, naming 1.0); 17 god classes, 985 long methods, 641 complexity violations, 1,138 code smells |
| Guarantees | Test gates, review, conventions | Nine invariants (the order of NODE_KINDS/EDGE_KINDS is a wire contract; a node id contains the line; file-order commit; synthesized edges carry synthesizedBy/registeredAt; a single chokepoint for path reads; kernel/wasm parity), crash repair after an interrupted bulk load, a WAL valve, agent-eval with protection against CLI contamination |
| AI Council | CodeGraph | |
|---|---|---|
| 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 companies, roles, license or multi-user model; the 11 agent hosts are integrations, not users |
| Interface | About 50 pages: code, graph, branches, quality, rules, review, knowledge, tickets, tasks, MCP Live, administration, System Health | MCP (1 tool by default), CLI (init, index, sync, status, explore, node, callers, callees, impact, affected, install, upgrade, uninstall and more), prompt hook, installer, docs site, a private telemetry dashboard; the browser viewer is not released (behind the CODEGRAPH_UI=1 flag) |
| Monitoring | Telemetry for every MCP call and hook without PII; about 22 Prometheus rules with tests; System Health, tracing | Anonymous telemetry is on by default and can be turned off; only completed UTC days, nothing on stdout, "off means off"; update checks. 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 | A fail-closed WAL valve, restoring indexes and FTS triggers after a crash during a bulk window, IndexHealth, an out-of-process liveness watchdog, a daemon/proxy that reconnects, worktree substitution detection, planned uninstall. No nightly backup or restore check |
| Storage | Neo4j, Qdrant, PostgreSQL per service, Temporal, NATS, Redis | One SQLite database in .codegraph/ per project: WAL, FTS5, 5 main tables plus service tables; no graph or vector database |
| Isolation | A sysbox container per task, one-time credentials for push, read-only knowledge reviewer, permission checks in a single gateway, SSRF protection | A local process; validatePathWithinRoot is the single chokepoint for reading source; the viewer listens on loopback and is protected against DNS rebinding. No sandbox, task isolation or multi-user isolation |
| Delivery | A distribution for self-hosted installation, or SaaS; on the developer's machine, MCP and hooks | npm @colbymchenry/codegraph, a self-contained bundle with Node 24, install.sh/install.ps1, npx, source; a Rust kernel with per-file fallback to wasm; MIT |
| License | Proprietary | MIT |
Among local tools, CodeGraph is the closest to Council's code understanding layer, but it solves a different problem. It builds a precise symbol graph and the flow across it; Council builds a graph plus knowledge, conventions, review and tasks. CodeGraph is stronger in the depth of reference resolution and in the discipline of a single tool; Council covers more layers, knowledge, rules and platform features.
Where CodeGraph is stronger:
isError only for real failures;dynamic-boundary-report, LOW_CONFIDENCE_MARKER, coverage and freshness banners, content-hash checks on responses;registeredAt;Where Council is stronger:
architecture_as_of). These are different axes: precision on one symbol versus understanding the whole project.ask_question returns excerpts with FQNs, not a model's paraphrase. CodeGraph keeps one root and one SQLite database, with no shared graph across repositories.Can they work together? Yes, they are different layers. CodeGraph is a precise local graph of symbols and flows; Council is a server for knowledge, rules, review and tasks. Both are MCP servers, so one agent can connect to both. They overlap on search and the graph: CodeGraph goes deeper in resolving symbols and flows, Council covers more of the architecture, knowledge and branches. There is no built-in integration. A practical setup: CodeGraph for "where is this and how does it work" on the developer's machine, Council for "what do we know about it, which rules apply, and what does review say".
Connect AI Council to one of your repositories and see the project graph, rules and review on your real code.