AI Council vs HumanLayer: what each one does

In short

AI Council is a self-hosted platform for development teams. 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 cover three scopes (code entities, paths, and the whole project), with MUST/SHOULD levels, states, and checks before an edit and on the diff. Around this you get review that publishes to the merge request (MR), tickets, tasks, and companies with roles and a license. Static code analysis doesn't use a model, but without a model that's all you have left: review, knowledge review, AI chat, and workspaces run through a host worker, a bridge, and the vendor CLI/OAuth. The model runs 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 through MCP and hooks: project rules arrive with every message, file context on Read/Edit/Bash, and a checklist at the end. In a workspace, the task runs on a VM in an isolated sysbox container, lives for days, and is driven by a person from the web UI, from analysis and diff to commit, push, and MR.

HumanLayer is an open-source (Apache 2.0) platform that runs coding agents on developers' machines and lets the team manage them from one place. The agents are Claude Code, Codex (CodeLayer), and Fold. Sessions started in a terminal are mirrored from OpenCode, Pi, and Claude Code. People work in a web app or a desktop app (Electron/Tauri). Each host runs a daemon that starts the agent, maintains the worktree, and sends events to the API. Tasks, sessions, plans and artifacts, approvals, diffs, commits, and PRs live in PostgreSQL. Electric SQL syncs them to clients, and durable streams carry the live feed. HumanLayer has organizations, roles, invites, billing, and usage metrics.

It is not a Council competitor on knowledge and the code graph. HumanLayer is closer to the Council workspace: both take a task from ticket to PR and keep a human in the loop. The difference is where the agent runs and what the system knows about the code. Council isolates the task in a container on a VM and understands the code itself. HumanLayer runs the agent on the developer's machine and gives the team a shared control panel.

1. Understanding the code

	AI Council	HumanLayer
Who reads the code	Council itself: it parses repositories and builds the graph. No model is called during analysis	The agent itself: the platform doesn't analyze code. It runs Claude Code, CodeLayer (Codex), or Fold and shows their sessions
When	On project creation, on push to main (polling), on demand, nightly. After an agent edits a file, that file and its dependents are recomputed	During the agent's turn. Between sessions the platform stores diffs, commits, PRs, and artifacts, but not the code structure
What it extracts	Layers L0–L10: stack, structure, dependencies and cycles, metrics and calls, data (ORM, DDL), architecture and forbidden dependencies, patterns, style, DDD, co-change links between files, code smells, ISO 25010 quality, diagrams	None of this. Only the working tree's git diff, commits, PR metadata, and task files. No graph, layers, metrics, or code smells
Languages	Python, PHP, TypeScript, JavaScript, Java, Kotlin, C#, C, C++, with full layer parsing	Any language the agent can read. No parsing of its own; diffs are handled by git, not per language
Multiple repositories	A project spans several repositories with a shared graph	A project and workspace describe several repositories (`repos[]`), and each task gets a worktree in each one. No shared graph across repositories
External analyzers	SonarQube: pulls in its findings. Own scanner (text languages, JVM, .NET, .NET Framework on Windows)	—
History	Edges are versioned after every run; `architecture_as_of` gives the architecture as of a date	Session history, artifact versions, a log of commits and PRs. 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 retelling them	No code search of its own: the agent searches with its own tools (grep/read). There is `doc-researcher` for libraries (Context7 + Exa) and context drawn from conversations

2. Knowledge and rules

	AI Council	HumanLayer
Knowledge base	Decisions, notes, Mermaid diagrams, changelogs. Each entry is tied to code and reaches the agent when it touches that file	No separate knowledge base about the code. There are context shards: fragments from conversations with up to 5 evidence quotes, which an organization can share with everyone and which the daemon injects into the prompt. There are task artifacts: research, PRD, TDD, plan, outline in `.humanlayer/tasks/<slug>/`, with versions, comments, and sharing. There are RPI and HumanLayer skills, and session history
Freshness	An entry holds its place in the code on its branch and goes back for re-check when the code under it changes, the entry itself changes, a similar entry appears, or the branch is merged. The reviewer must cite a quote; the result is a freshness label	Not re-checked. Artifacts are versioned and context shards carry evidence, but there is no link to code and no "is this outdated?" check
Branches	Knowledge and the graph are stored per branch. The agent sees its branch, the parent, and what was merged. On merge, the entry moves over	A worktree per task and repository, with the session tied to a branch. Context shards are per organization, artifacts per task. No per-branch knowledge
Rules	Conventions in three scopes: code entities, paths (they apply even to a file that doesn't exist yet), and the whole project. MUST/SHOULD, with "draft", "deferred", and "deleted" states. Checked before an edit and on the diff	`CLAUDE.md`/`AGENTS.md` as text, RPI skills, workspace config, workflow types. No rules engine tied to code and paths, and no checks before an edit or on the diff
How it reaches the agent	Claude Code hooks: project rules with every message, a broad channel before an action, file context on Read/Edit/Bash, a checklist at the end; a "knowledge base first" gate	Agent plugins and hooks: a Claude Code plugin, an OpenCode plugin, a Pi extension. They mirror the session, let the web app reply/stop/approve, inject context shards into the prompt, and install skills. No per-file rule delivery
MCP	Server: about 60 tools, profiles, modes, XML with a budget	An MCP server inside the Claude Code plugin (stdio + Unix socket) for mirroring and control; agent-neutral tools for comments on artifacts and diffs, `library_researcher`. It's a client/platform, not a knowledge server
Portability	Export and import knowledge as a package, copy between projects	Artifacts sync between machines, public links to artifacts, task files. No knowledge transfer as a package

3. Requirements and tasks

	AI Council	HumanLayer
Requirements	Traces tests to requirements by tags: coverage and gaps. "No test" is a tri-state, not requirements management	PRD/TDD and phase artifacts: research questions, research, design, outline, plan. No "test → requirement" link; there is a process with checkpoints
Tickets	Jira, GitHub Issues, Redmine: reading, turning tickets into knowledge, advice on a ticket from the graph	GitHub Issues (import), Linear, Jira: a task is created from a ticket, and its status moves automatically through the RPI phases; Slack notifications. Broader and deeper than Council
Working on your own machine	The agent is the developer's Claude Code. Council supplies context and rules through MCP and hooks; review of the local diff, diff breakdown, checking the diff against rules	This is the main mode: a daemon on the developer's machine runs the agent, and the web/desktop apps control it. Terminal sessions from Claude Code, OpenCode, and Pi are mirrored. Supports Claude Code, CodeLayer (Codex), Fold
Workspace	Tasks run on a VM in a sysbox container and live for days; a person drives them from chat; a mentor; diff → commit → push → MR	Tasks and sessions on the user's host, a worktree per task and repository, setup commands, approvals, a message queue, multiplayer, artifacts, a PR panel. No isolation on a separate VM: the agent runs with the user's permissions
Process	A task state machine: created → analysis → in progress → MR → closed. A person defines what each step contains	RPI: research → design → plan → implement, with checkpoints; types `rpi`, `outline_only`, `prd_tdd`, `oneshot`, `freeform`; auto-advance between phases; PRD/TDD as separate artifacts
PR	Review that publishes to the MR (GitHub, GitLab, Bitbucket)	A PR panel through a GitHub App: checks, threads, merge state, merge/close/reopen/ready/auto-merge/update branch; a PR status stream; commit and PR attribution. No AI review

4. Verification and models

	AI Council	HumanLayer
Code review	A separate service: looks at what changed, gives a verdict per file, runs a second pass, publishes to the MR without duplicates	No AI code review. There is human review: anchored comments on artifacts, comments on the diff, a PR panel with checks and threads
Checkpoints	— (no acceptance against a spec)	PRD, TDD, and outline require human approval. Feedback on the outline changes the outline rather than starting implementation. Auto-advance can skip the pause but doesn't change the artifact
Models	A model is required: two processes on the host use the vendor's OAuth, for AI chat and six background jobs (review, knowledge review, ticket analysis, and others). Without a model, only static code analysis remains.	Agents use credentials on the host: sign-in to Claude/Codex/xAI through provider login. Platform AI agents (title, summary, next step, context shards, task intent, doc researcher) go through a reliable model (primary/secondary); a model catalog, usage, and cost per session
Agents	Claude Code and Codex (hooks, MCP); MCP is available to any client	Claude Code, CodeLayer (Codex), Fold; OpenCode, Pi, and Claude Code are mirrored. Several agents on one host
Cost and tracking	Telemetry for every MCP and hook call; an agent searching again is a sign the first answer was poor	`session_usage_events` by model, session cost, metrics `costPerKlocByModel`, `modelSpendTrend`, `usageByModel`; Stripe billing and seats

5. Platform

	AI Council	HumanLayer
Users	Companies → members → roles (can be per project) → permissions. Company API keys. Data is separated: a request without a company is rejected. License and seat limits	Organizations → teams → projects → workspace → tasks → sessions. WorkOS (JWT), roles/admin, task and session ACLs, multiplayer prompting, public links to artifacts, Stripe (plans, seats, trial)
Interface	About 50 pages: code, graph, branches, quality, rules, review, knowledge, tickets, tasks, MCP Live, administration, System Health	A React 19 web app (47 routes: board, sessions, tasks, artifacts, PRs, context shards, settings, billing, hosts), Electron and Tauri desktop apps, mobile web, the `humanlayer` CLI, mirroring plugins, a separate admin app
Monitoring	Telemetry for every MCP and hook call without PII; about 22 Prometheus rules with tests; System Health, tracing	Sentry, PostHog, structured logs, host heartbeat and stats, a sync health tracker, metrics pages (activity, commits, PRs, cost). No Prometheus/System Health infrastructure stack
Self-healing	Reconciles Temporal with the database, cleans up orphaned data, deletes projects in batches, nightly backup with restore verification, telemetry retention	`stale-daemon-sweeper` (lost sessions, offline/lost hosts, ephemeral hosts), 90-day retention for CodeLayer snapshots, daemon self-update, one automatic daemon restart, session status repair, idempotent events, stream rehydration. Backup and restore verification aren't described in the codebase
Storage	Neo4j, Qdrant, PostgreSQL per service, Temporal, NATS, Redis	PostgreSQL 18 as the source of truth (58 tables), Electric SQL 1.7 as the read model, durable streams (Rust) for the live feed, Redis for the billing cache, S3/MinIO for artifacts, Yjs for collaborative editing
Isolation	A sysbox container per task, single-use credentials for push, a read-only knowledge reviewer, permission checks in a single gateway, SSRF protection	The agent runs on the host with the user's file and network permissions; there is no sandbox, and approvals are a UX aid. WorkOS/daemon RS256/launch token, task and session ACLs, host ownership checks, public share keys. The daemon gives the agent the user's permissions, so restricted accounts are recommended
Delivery	A distribution for self-hosted installation, or SaaS; MCP and hooks on the developer's machine	An open Apache 2.0 monorepo; for development, a devstack (Postgres, Electric, MinIO, durable streams, Redis) in Docker; desktop builds, CLI. The product is a cloud SaaS (WorkOS, Stripe, AWS Lambda). Deployment in an air-gapped environment isn't described in the codebase
License	Proprietary	Apache 2.0

Bottom line

HumanLayer is not a Council competitor on knowledge and the code graph. It's a control panel for a team's coding agents: tasks, sessions, workspaces, approvals, artifacts, PRs, organizations, and billing. It's closer to the Council workspace than to Council's code analysis, but it solves a different problem. Council isolates the task on a VM and understands the code itself. HumanLayer runs the agent on the developer's machine and makes the team's work visible and manageable.

Where HumanLayer is stronger:

human control over the agent: approvals, a message queue, interrupt, multiplayer;
process: RPI (research → design → plan → implement), PRD/TDD, checkpoints, auto-advance, automatic status updates in Linear;
multiple agents: Claude Code, CodeLayer (Codex), Fold, with OpenCode and Pi mirrored;
teamwork: artifacts with anchored comments, public links, collaborative editing;
PRs and attribution: a PR panel, checks, auto-merge, a commit log (confirmed/inferred/human), cost and output metrics;
organizations, roles, invites, billing, and seats;
Apache 2.0 open source and live sync through Electric/durable streams.

Where Council is stronger:

It understands the code; HumanLayer manages the agent working on it. The L0–L10 graph: stack, structure, dependencies and cycles, calls, data, architecture and forbidden dependencies, patterns, style, DDD, co-change, code smells, ISO 25010, diagrams. Static analysis doesn't call a model. HumanLayer gives you a control panel, not project analysis.
Knowledge is tied to code and branches. An entry lives on a branch, reaches the agent when it touches the file, and goes back for re-check when the code under it changes; the reviewer must cite a quote. HumanLayer has artifacts and comments, but knowledge isn't tied to a position in the code or checked against it.
Conventions are checked before an edit and on the diff. Three scopes (entities, paths including files that don't exist yet, and the project); MUST/SHOULD, states, hook delivery with every message, and file context on Read/Edit/Bash. The "knowledge base first" gate blocks reading code until the agent has queried the knowledge base. HumanLayer manages approvals, not code rules.
Code and knowledge review is a service. A verdict per file, a second pass, publishing to the MR without duplicates; a separate knowledge review with quotes and calibration. HumanLayer has a PR panel and checks, but its review doesn't know the graph, the knowledge, or the conventions.
Task isolation is stronger than a worktree on the host. The task lives on a VM in a sysbox container for days, with single-use push credentials, RBAC, and SSRF protection; a person drives it from the web UI. HumanLayer runs the agent on the developer's machine in a worktree. That's more convenient for the local loop but weaker on isolation.
Self-hosted/offline and permissions. Companies → members → roles (including per project) → permissions, company API keys, license and seats; shipped as a distribution for self-hosted installation, or as SaaS. HumanLayer is Apache 2.0 and a cloud SaaS with organizations and billing; deployment in an air-gapped environment isn't described in the codebase.
Observability at the level of tool and hook calls. Telemetry for every MCP and hook call without PII, repeat agent searches as a signal, about 22 Prometheus rules, System Health, tracing; Temporal reconciliation with the database, orphaned data cleanup, backups with restore verification. HumanLayer has cost and output metrics, but not per-call tool observability.

Can they work together? Yes, and they are different layers. HumanLayer runs and manages the agent; Council provides the graph, knowledge, rules, and review. An agent managed by HumanLayer (Claude Code or OpenCode) can call Council's MCP for context. But there is no automatic integration. HumanLayer's plugins mirror and control the session; they don't deliver Council rules per file. Council's hooks are written for Claude Code and would have to be wired into the HumanLayer plugin. The two systems also don't share tasks or sessions: Council has its own state machine and VMs, HumanLayer has worktrees on the host.

AI Council and HumanLayer: what each one does