Made on
Tilda
AI Council is a platform for development teams that runs on your own server or in the cloud. It parses your repositories into a code graph on its own: stack, structure, dependencies and cycles, calls, data, 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 tied to a place in the code and to a branch, and it reaches the agent when the agent touches that file. Conventions are a separate layer: rules at three scopes (code entities, paths and the whole project) with MUST/SHOULD levels, states, and checks before the edit and on the diff. Around this you get review that publishes to the MR, tickets, tasks, and companies with roles and licensing. Static code analysis doesn't use a model. Review, knowledge review, AI chat and workspaces run through a host worker, a bridge and the vendor's CLI with the vendor's OAuth. Council has no LLM key of its own.
There are two ways to work with Council. On a developer's machine, Claude Code or Codex connects to it through MCP and hooks: project rules arrive with every message, file context on Read/Edit/Bash, and a checklist at the end of each turn. In a workspace, a task runs on a VM in an isolated sysbox container, lives for days, and a person drives it from the web UI, from analysis and diff to commit, push and MR.
GitHub Copilot is a subscription AI assistant built into GitHub and into editors. It's not one program but a family of surfaces on a shared base:
You can pick models from six vendors (OpenAI, Anthropic, Google, xAI, Microsoft, Moonshot) or let it choose automatically. Since June 1, 2026, usage is billed in AI Credits by tokens. Everything runs in GitHub's cloud.
It's not a direct competitor to Council but a neighboring layer. Copilot does the work and assists: it writes code, runs agents and reviews PRs. Council is the source of truth about the code and the rules underneath the agent. They overlap in three places: project memory (Copilot Memory vs. Council's knowledge base), rules (Copilot instructions vs. conventions) and PR review. Copilot is stronger in day-to-day work and in everything tied to GitHub. Council is stronger in code understanding, in knowledge and rules that get checked, and in keeping everything on your side.
| AI Council | GitHub Copilot | |
|---|---|---|
| Who reads the code | Council itself: it parses the repositories and builds a graph. No model is called during analysis | The model, at request time: it reads files, searches the repository and calls tools. There's no persistent code graph |
| When | On project creation, on push to main (polling), on demand, nightly; after the agent edits a file, that file and its dependents are recomputed | During the turn. A semantic repository index builds itself when a chat with repository context starts (up to 60 s on a large repository, faster on re-index); the cloud agent uses the same search with no setup |
| 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 for semantic search, plus whatever the model reads itself. No dependencies, architecture layers, DDD, quality metrics or diagrams as analysis output; code quality is a separate product, GitHub Code Quality, built on CodeQL |
| Languages | Python, PHP, TypeScript, JavaScript, Java, Kotlin, C#, C, C++, with full layer analysis | Any language the model understands; no per-language analysis |
| Multiple repositories | A project made of several repositories with a shared graph | Chat and Spaces see several repositories; the cloud agent only changes the repository chosen when the task starts |
| History | Edges are versioned after every run; architecture_as_of returns the architecture as of a date | Git and PR history on GitHub; no architecture history |
| Search | Semantic and regex search, find_usages, find_path, dependency graph, similar implementations; ask_question returns excerpts from the knowledge base without a model paraphrase | Semantic search over the index, GitHub Code Search, the agent's usual grep/glob. The answer is a model paraphrase |
| Context collections | The whole project: graph, knowledge and rules are delivered automatically where the edit happens | Spaces: a collection of repositories, files, PRs, issues, notes, images and uploads; GitHub sources update on their own; can be shared with the organization or publicly; available in the IDE through the GitHub MCP server |
| AI Council | GitHub Copilot | |
|---|---|---|
| Project memory | Knowledge base: decisions, notes, Mermaid diagrams, changelogs. Entries are written deliberately (by the agent via store_knowledge or by a person); drafts from MRs are machine-written but only become knowledge after someone confirms them. Every entry is tied to code | Copilot Memory (public preview): agents save facts about the repository on their own (conventions, decisions, build commands) with citations from the code, plus user preferences. Shared across the cloud agent, code review, CLI and autofix. Facts are only created from actions by people with write access. The repository owner can view and delete facts |
| 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 quote the code verbatim; the result is a label, and the entry text is left untouched | Before use, a fact is checked against its citations on the current branch; only verified facts are used. An unused fact is deleted after 28 days; the timer resets on each verified use. User preferences are checked by "model judgment", not against code |
| Branches | Knowledge and the graph are stored per branch; the agent sees its own branch, the parent and merged work; on merge the entry moves over | A fact is checked against the current branch; no per-branch knowledge and no carry-over on merge |
| Rules | Conventions at three scopes: code entities, paths (they apply even to a file that doesn't exist yet), the whole project. MUST/SHOULD, states "draft", "deferred", "deleted". Checks before the edit and on the diff | Instructions: repository-wide (.github/copilot-instructions.md), per path (.github/instructions/*.instructions.md), agent files (AGENTS.md, CLAUDE.md, GEMINI.md), personal and organization-level (Business/Enterprise). Sent with every message. GitHub states plainly that instructions don't guarantee policy compliance. No MUST/SHOULD levels, no states, no diff checks against rules |
| 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 of the turn; a "knowledge base first" gate, so the agent can't open code until it has asked the knowledge base | Instructions go into every request. Hooks (CLI; the cloud agent supports some events; VS Code in preview): sessionStart can add context (up to 10 MiB), preToolUse can allow, deny with a reason for the agent, or rewrite arguments, postToolUse can add context (up to 10 KB), agentStop can keep the agent from finishing. Output from userPromptSubmitted command hooks is discarded. The CLI also reads hooks from the repository's .claude/settings.json. Hooks don't ship with rules; the team writes the scripts itself |
| Skills | The ai-council skill and slash commands are installed by a single hook installer | Agent skills, an open format; read from .github/skills, .claude/skills, .agents/skills and personal folders; loaded when needed. Custom agents are supported (.github/agents) |
| MCP | Server: about 60 tools, profiles, per-session modes, XML responses with a size cap | Client on every agent surface: IDE, CLI, cloud agent, code review (GitHub and Playwright MCP are on by default). For enterprises: a policy, an internal registry and a server allowlist. No MCP server for code knowledge of its own, apart from GitHub MCP |
| Portability | Bulk export and import of knowledge, copying between projects | Instructions, skills and hooks are files in the repository and move with it. Memory facts stay within their repository; a Business/Enterprise admin can export or delete user preferences |
| AI Council | GitHub Copilot | |
|---|---|---|
| Requirements | Test-to-requirement links | No test-to-requirement links |
| Tickets | Jira, GitHub Issues, Redmine: reading, breaking tickets down into knowledge, ticket advice from the graph | A task can be handed to the cloud agent from a GitHub issue, Slack, Teams, Jira, Linear or Azure Boards. Tickets aren't broken down into knowledge |
| Working on your own machine | The agent is the developer's Claude Code; Council supplies context and rules through MCP and hooks; local diff review, diff breakdown, diff checks against rules | This is Copilot's main mode: completions, chat and agent in the IDE, Copilot CLI in the terminal, the Copilot app with parallel sessions in worktrees and a local sandbox |
| Background agent | Tasks on a VM in a sysbox container that live for days; a person drives them from the UI chat; a mentor; diff → commit → push → MR | Cloud agent: ephemeral GitHub Actions environment, sessions up to 59 minutes (can't be extended), one repository and one branch per task, GitHub repositories only. Can work on a branch without a PR. Automations on a schedule and on repository events. Third-party Claude and Codex agents on Agent HQ, in public preview since February 2026 |
| PR | Review that publishes to the MR (GitHub, GitLab, Bitbucket) | PR creation by the cloud agent, review, and Agent Merge in the app: it watches CI and required reviewers, fixes failing checks, and can merge |
| Process | A task state machine: created → analysis → in progress → MR → closed; a person defines what happens at each step | A task lives as an agent session and a PR on GitHub; the overview is in the app's "My Work" and the agents panel |
| AI Council | GitHub Copilot | |
|---|---|---|
| Code review | A separate service: looks at what changed, gives a verdict per file, runs a second pass, publishes to the MR without duplicates; knowledge review is separate | A PR reviewer: manual or automatic via rulesets; gathers context across the whole repository; agentic features run on GitHub Actions; reads instructions and skills from the head branch; connects MCP; uses memory. Effort levels (Lite, and Balanced by default), /security-review. Can hand fixes to the cloud agent as a separate PR. By default its review doesn't count as an approval; counted approvals are in preview. Platforms: GitHub and Azure DevOps (preview). Rough cost: $0.05 to $5 per review plus Actions minutes |
| Models | No key of its own. Two processes on the host via the vendor's OAuth: AI chat (runners for claude and codex) and six background jobs on claude -p (review, knowledge review, ticket breakdown and others). Code analysis doesn't use a model | OpenAI, Anthropic, Google, xAI, Microsoft, Moonshot; automatic model selection in the cloud agent, chat, CLI and app. You can't choose the model for code review |
| Your own models and air-gapped setups | The Council server installs from an offline bundle, but the agent and model jobs still need the vendor's CLI with OAuth. A corporate model server via ANTHROPIC_BASE_URL and a runner inside a closed network are on the roadmap, not built yet | Copilot CLI: bring your own key (Azure OpenAI, Anthropic, any OpenAI-compatible endpoint including Ollama, vLLM, Foundry Local) and COPILOT_OFFLINE=true, with no calls to GitHub and no telemetry; fully isolated if the model is local. Org-level custom models for chat, CLI and IDE on Business/Enterprise. All other surfaces are GitHub cloud only |
| Agents | Claude Code and Codex (hooks, MCP); MCP is open to any client | Its own agent on every surface; the Copilot SDK (GA: Node.js/TypeScript, Python, Go, .NET, Rust, Java) exposes the same agent runtime for your own tools; third-party agents on Agent HQ |
| Measurement | Telemetry on every MCP call and hook; a repeated search by the agent signals a poor first answer | A 28-day usage dashboard at the organization and enterprise level, with API export; shows who uses it and how much, but not how good the answers are |
| Guarantees | Test gates, review, conventions | preToolUse hooks can deterministically block an action; sandboxes, session isolation in worktrees; GitHub warns that review "is not guaranteed to find all issues" and that the agent can produce incorrect code |
| AI Council | GitHub Copilot | |
|---|---|---|
| Where it runs | On your side (docker compose or an offline bundle) or in the cloud; on the developer's machine, MCP and hooks | In GitHub's cloud. Licenses are issued only through GitHub.com or GHE.com; GitHub Enterprise Server gets only some features |
| Users | Companies → members → roles (can be per project) → permissions. Company API keys. Data is isolated: a request without a company is rejected. License and seat limits | GitHub organizations and enterprises, Copilot policies, content exclusion from context (changes are recorded in the audit log), MCP policy and allowlist |
| Interface | About 50 pages: code, graph, branches, quality, rules, review, knowledge, tickets, tasks, MCP Live, administration, System Health | IDE, GitHub.com, mobile app, CLI, the Copilot desktop app, and Slack/Teams and trackers as task entry points |
| Monitoring | Telemetry on every MCP call and hook, with no PII; about 22 Prometheus rules with tests; System Health, tracing | Usage metrics and an audit log at the organization and enterprise level |
| Self-healing | Temporal-to-database reconciliation, cleanup of orphaned data, batched project deletion, nightly backup with restore verification, telemetry retention | GitHub's job: it's a service |
| Data | The graph, knowledge and rules stay in your installation (Neo4j, Qdrant, PostgreSQL across services). What goes to the vendor's cloud is whatever the vendor's CLI sends to the model | In GitHub's cloud; data residency (US or EU) on GitHub Enterprise Cloud with data residency; the repository index isn't used to train models |
| Isolation | A sysbox container per task, one-time credentials for push, a read-only knowledge reviewer, permission checks in a single gateway, SSRF protection | Cloud agent: an ephemeral Actions environment that commits only to its own branch; the app: a local sandbox with file and network limits, or a cloud one; every session in its own worktree |
| Price | Startup: $30 per user per month, up to 10 users; Standard: $20 per user per month, 10 to 50 users; Enterprise (50+ users or air-gapped): custom quote. LLM tokens are paid to the model provider directly | Free; Pro $10; Pro+ $39; Max for heavy usage; Business $19 per seat; Enterprise $39 per seat. Since June 1, 2026, a monthly AI Credits allowance with token-based billing at each model's price; completions and next edit suggestions don't use credits |
| License | Proprietary | Proprietary service |
Copilot is not a direct competitor to Council but a neighboring layer. It's an assistant built into GitHub that does the work: it writes code in the editor, runs cloud agents, reviews PRs, and covers all of it with one subscription. Council is the source of truth about the code and the rules. It runs on your side and gives the agent what the agent can't find out on its own. They meet head-on in three places: project memory, rules and PR review.
Where Copilot is stronger:
.claude/skills), MCP with a registry and allowlist for enterprises, AGENTS.md/CLAUDE.md. Copilot partly picks up what your team already wrote for other tools.Where Council is stronger:
Can they work together? Yes, and they pair naturally: Copilot is the assistant and PR bot, Council is the code knowledge and rules underneath. The main path is MCP. Copilot in the IDE, Copilot CLI, the cloud agent and code review all connect MCP servers, so Council's tools (brief_me_on, list_knowledge, check_conventions_before_editing, check_diff_conventions, search_code) are available to them. There's one serious limitation: the cloud agent and code review run in GitHub's cloud and can only reach Council if the server is reachable from there. In an air-gapped setup, you're left with the IDE and CLI on the developer's machine.
Council's hooks don't exist for Copilot, but Copilot now has its own, and the CLI even reads the repository's .claude/settings.json. Its channels are narrower than Claude Code's. Output from userPromptSubmitted command hooks is discarded, so you can't deliver rules with every message that way, and post-tool context is capped at 10 KB, while Council's file context can be larger. On the other hand, sessionStart accepts up to 10 MiB, and a preToolUse denial carries a reason to the agent. That's enough to hand over rules at session start and enforce the "knowledge base first" gate. So an adapter is possible, but it doesn't exist yet and hasn't been tested. If you turn on both memories, Copilot Memory and Council's knowledge base, they will know different things about the project, so decide up front which one is the source of truth. And as with any PR bot, split the review work: Copilot for a fast first pass, Council for the deep pass with the graph and rules, rather than two independent comments on the same thing.
Copilot details are based on GitHub's documentation and blog as of October 27, 2026. Copilot's code is closed and wasn't examined. Copilot Memory, the Copilot app, hooks in VS Code, review in Azure DevOps, counted approvals and third-party agents on Agent HQ are in public preview and may change.
Connect a real repository and see how the platform behaves on your code, not on a canned demo.