AI Council and skillmem: 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.

skillmem is a local procedural memory layer for coding agents (Claude Code, Codex CLI, Cursor, Windsurf, Gemini CLI, opencode). It stores procedures rather than facts about the user: trigger, steps, outcome, lessons. Writing costs $0: no LLM calls on write or read, data lives in SQLite, and semantics come from a local 384-dimension ONNX model. The product loop is learn, recall, reinforce, decay. Only external evidence moves an entry's strength (a test passed, a diff was accepted, a person confirmed); the agent's self-assessment doesn't. Nightly decay moves entries active → stale → archived. It has a trust model (origin, trusted_at, owner_seal, an UNTRUSTED frame), five Claude Code hooks (auto-recall, tool-recall, session-recap, pending-rules), 9 MCP tools, an HTTP API with tokens, a CLI, Markdown export, and 16 invariants with property tests. Apache-2.0.

It is the closest to Council in its memory and delivery layer, but not in code understanding: skillmem stores procedures and notes, not knowledge anchored to positions in the code. Council builds a graph and checks knowledge against the code; skillmem checks where a text came from and whether the owner approved it.

1. Understanding the code

2. Knowledge and rules

3. Requirements and tasks

4. Verification and models

5. Platform

Bottom line

skillmem is the closest to Council in its memory and delivery layer, but not in code understanding. It stores procedures and lessons, while Council stores knowledge about decisions anchored to code positions, plus team rules. They define truth differently: Council checks an entry against the code with a reviewer's quote; skillmem checks where the text came from and whether the owner explicitly approved it. The two approaches complement each other.

Where skillmem is stronger:

• procedural memory with a lifecycle: learn, recall, reinforce, decay, archive, plus pinning and restore;
• a trust model: origin, trusted_at, owner_seal, the UNTRUSTED frame, TTY-based owner gates; unapproved text doesn't become a rule;
• automatic recall on prompt and on tool use, session recap with a tool-less summarizer;
• local and $0: SQLite, FTS5, ONNX, no API keys for write or read;
• Markdown export, import-vault, packs, migrate with round-trip;
• 16 invariants, property tests, a release gate;
• measured effectiveness: LongMemEval hit@5 0.871/0.889 and an outcome A/B;
• Apache-2.0.

Where Council is stronger:

• Understands code, not just procedures. 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. skillmem stores "how to do it", 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. skillmem has origin, trust and owner seal, but checks against owner approval, not against the code.
• 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. skillmem delivers procedures and feedback, but not code rules with a scope.
• 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. skillmem 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; tickets, requirements tracing, companies, roles and licensing. skillmem is local memory and doesn't have this layer.
• Shared graph across repositories, architecture history, SonarQube. architecture_as_of, versioned edges, an external analyzer; ask_question returns excerpts with FQNs. skillmem works with text, not 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. skillmem has invariants and a release gate, but not per-call platform observability.

Can they work together? Yes, they are different layers. skillmem stores "how to do it": procedures, lessons, confirmed rules. Council stores "why it's done this way": decisions anchored to code, and team conventions. Both work through Claude Code hooks and MCP, so they can live in the same session. They overlap on delivery at prompt and tool time: skillmem injects procedures and feedback, Council injects rules and per-file knowledge. There is no built-in integration, but connecting both to one agent is easy.