Controlled AI-agent development, persistent memory and context management
AI Council remembers your project's architecture, agreements and decisions — and delivers them to the AI agent exactly when it works. Runs on top of Claude Code, OpenAI Codex and Gemini CLI, and connects to any MCP-compatible agent or IDE.
- Claude Code
- OpenAI Codex
- Qwen
- Gemini CLI · and any MCP-compatible agent
Markdown files work. Until the project grows and the team does too
Most development teams already keep context in CLAUDE.md, cursor rules or notes. AI Council does not argue with that approach — it knows where it ends.
CLAUDE.md in the repo
- Files grow stale; the agent re-reads the entire content, including outdated parts.
- Knowledge isn't linked to code entities: a module moves, the rule silently points at the old one.
- No team deduplication or shared memory — every developer keeps their own file.
- No verification that the agent actually followed a rule.
AI Council
- Knowledge lives in a graph, linked to concrete modules, layers and code entities.
- The agent gets a precise, token-budgeted slice of context per task — not the whole file.
- One shared team knowledge base — a decision found by one developer works for everyone, deduplicated.
- A mentor agent reviews the plan and the implementation against conventions, online.
A memory and control layer between your codebase and the AI agent
In large, long-lived projects AI agents lack durable context. AI Council solves five specific problems.
Context preservation
The Knowledge Graph stores decisions and conventions, linked to code and scoped to git branches: work on a feature branch stays isolated until merge, then flows automatically into the target branch.
Efficient retrieval
RAG assembles context from a token budget (~8K tokens of precisely ranked chunks) instead of dumping 100K+ tokens of raw files.
Automated conventions
Project rules are delivered to the agent via MCP and hooks — no need to repeat them in every prompt.
Quality oversight
A mentor agent reviews the plan and implementation pair-programming-style, and a dedicated MCP tool checks the diff itself against mandatory conventions before commit.
Answers for the whole team
A project-level chat for product managers and analysts: how something is implemented, which ticket fixed it, what the team decided — answers with source references, scoped to the asking person's own role (RBAC), read-only.
The loop: analyze → develop → capture knowledge → re-analyze
Set conventions
Architectural constraints, coding style, no-go zones in legacy directories.
Analyze the project
AI Council builds a graph of objects and dependencies and captures architectural knowledge.
Develop with your AI agent
In Workspace mode the task runs on its own git branch — existing or freshly cut — with the diff scoped to the commit where the task was created; hooks feed the agent knowledge and conventions as it works.
Capture new knowledge
Decisions, diagrams and module notes are stored, linked to the code and to the branch they were created on.
Re-analyze changes
Once the branch merges, its knowledge flows into the target branch automatically; fast incremental analysis runs after edits, deep analysis after the session ends.
How AI Council differs from Claude Code, Cursor and memory layers
The honest answer: AI Council does not replace agents, and memory tools solve a neighboring but different problem.
Agents & IDEs
Claude Code, Cursor, Windsurf, OpenCode. They write code — and do it well. AI Council works on top of them via MCP, adding what none of them have on their own: a task modeled as branch + fixed diff range, not just "whatever's open in the working copy."
Memory layers
OpenMemory, Supermemory, Pi, Hermes. They store notes and facts, but not scoped to git branches — a note saved on an experimental branch stays visible everywhere. AI Council links knowledge to code entities and scopes it to branches, the way git itself does: nothing leaks from a parallel branch until it's merged.
DIY on files
CLAUDE.md + your own repo. Works great solo on a small project. Breaks down with a team, legacy code and a living dependency graph — and CLAUDE.md has no concept of a branch at all: one file per repo, whichever branch you're on.
Not just developers — the whole team
The project chat, tickets and knowledge base work for everyone — scoped to the asking person's actual role (RBAC).
Developer
Fast onboarding, precise context at work time, less manual digging through code and history.
Analyst
Requirements, tickets and code linked together: "which ticket did this," what was decided and where it lives in code.
QA engineer
Implementation completeness, conventions and quality: smells, layer violations, context for verifying a ticket.
Manager / product
Project chat scoped to their own role: status, decisions and "why it was done this way" — without pulling developers away.
Support
Answers to user questions straight from the project knowledge base — as in the CNC software case.
Technical writer
Up-to-date architecture from the graph: C4 diagrams, decisions and changelog — not a stale wiki.
Results from real projects
Numbers depend on the project and the team, so here are concrete stories instead of averaged percentages.
CNC machine software
Expensive engineers kept being pulled away by repetitive configuration questions. A built-in AI bot now answers them from the project knowledge base — developers stay on task.
Legacy project
A task for a new developer was estimated at 350–400 hours. With AI Council it took about 40 — standards kept, fully verified by QA.
DWH development
The project started in AI Council from day one. Tasks were completed 2.5× faster than team-lead estimates on average.
Linked projects
Two related projects, each built by its own team within one company: ERP and DWH. AI Council works across both at once — teams got 4× faster on linked tasks: integrations, error-case resolution, writing specs.
Transparent pricing — and payback you can compute
Start free: a 2-month trial with unlimited users and projects. All plans include product updates: new features, languages and LLM integrations.
Unlimited projects.
All platform features, shared team knowledge base.
Self-hosted, isolated network perimeter, custom security requirements.
Frequently asked questions
Can I use something other than Claude?
Yes. Anthropic Claude, OpenAI Codex and Google Gemini are all supported as agent backends, and the list keeps growing — including open-source models.
Which programming languages are supported?
PHP, Python, TypeScript, Java, Kotlin, C#, C and C++ — 8 languages with full parser support. The list is actively expanding.
Can it be self-hosted?
Yes — available as SaaS or installed on your own infrastructure with a license key.
Do I need a separate LLM license?
Bring your own provider key for commercial models, or run an open-source model on your own servers.
Who keeps the knowledge base tidy?
An autonomous curator. Every night it compares all entries semantically: obvious duplicates are merged automatically, borderline cases go to a human review queue, and test junk with no link to code is cleaned up. Every action is reversible and visible in the project's curator log.
Can I connect a ticket tracker?
Yes. AI Council connects to your tracker (e.g. Redmine) and doesn't just mirror tickets: a background process distills each ticket into a knowledge entry linked to the code it touched. "Where was this done" searches both tickets and the knowledge around them.
Try accelerating your development with AI Council — free for 2 months
The AI Council team will demo the product on a call, discuss your stack and help you run a pilot on a real project. No user or project limits during the trial.