Code review agents
that understand structure
Most AI review tools skim a diff and guess. Codesteward runs multi-agent reviews against a structural code graph — call chains, dependencies, auth paths — so findings are grounded in how your codebase actually works. Gate every merge. Steward every branch.
Reviews on the forge you already use
PR gate with check runs on GitHub · review comments across all five
Two ways to review. One finding schema.
A merge gate and continuous branch stewardship on the same platform — same findings, same policy model, same learning loop.
Gate
Block risky merges
Runs when a PR opens, on push, or when someone comments @codesteward review. Reviews the diff, posts inline comments, and returns a pass/fail check run so branch protection can hold the merge.
- Trigger
- PR open · push · mention
- Scope
- Diff-focused units
- Output
- Inline review · check run · verdict
- Verdicts
- approve · comment · request changes
Stewardship
Hold the line over time
Continuous review on long-lived branches and paths — no PR required. Batches by package or path and maintains a durable findings lifecycle, so drift and debt surface before they become incidents.
- Trigger
- Scheduled · on demand
- Scope
- Package · path · tree batches
- Output
- Durable findings lifecycle
- Statuses
- open · fixed · dismissed · reopened
Not one model guessing at a patch
Every review moves through the same staged pipeline. Specialists run concurrently, a verifier challenges what they found, and a deterministic judge decides what is worth your attention.
Correctness
Logic bugs, race conditions, error handling, null and edge cases, invariant violations.
Security
Injection, authz/authn gaps, secrets, SSRF, path traversal, insecure crypto, taint flows.
Performance
N+1 queries, unbounded loops, memory leaks, blocking I/O on hot paths, complexity.
Testing
Missing tests for critical paths, brittle tests, untested error branches.
Rules
Enforces your STEWARD.md and path-scoped rules, citing the rule id on every finding.
Requirements
Checks the change against stated PR goals and missing acceptance criteria.
Depth you choose
Risk tiers from trivial to thorough decide which specialists run. A typo fix does not pay for a security review.
A verifier that says no
A second pass rules on every candidate — keep, drop, downgrade, upgrade — before anything reaches your PR.
A judge that is not a model
Severity floor, nit cap, fingerprint dedupe, and convergence on prior-closed findings — deterministic, not another opinion.
Built to be trusted with the merge button
Policy loads from the base branch — only
Your STEWARD.md and path rules are read from the base branch, never from the PR head. An author cannot relax the gate in the same pull request the gate is judging — the policy is the team's, not the author's.
Graph as evidence, source as truth
Specialists read the code first and use the graph for callers, auth, and cross-file edges. Findings carry the structural edges they relied on. Line-level bugs are never asserted from topology alone.
It tells you why it found nothing
A clean review returns a machine-readable rationale — empty diff, all units clean, all candidates dropped, context missing. Silence is never mistaken for safety.
Degraded graph can fail the gate
When policy requires structural evidence and the graph is unavailable, the check fails loudly rather than quietly pretending the review happened.
It gets quieter as you use it
👍/👎, dismissals, and org memories apply at three scopes — org, repo, and a single PR — and are enforced twice: in the specialist prompt and again at the judge.
Every run is auditable
Per-specialist model, duration, tool calls, and response hash — plus every dropped finding with the reason it was dropped. Reconstruct any review after the fact.
One system, assembled from parts that stand alone
Codesteward Review is the product. Everything else is a component of it — each one independently useful, each one feeding the review with context no diff can carry.
Graph Server
Parses your repository into a deterministic graph — call chains, inheritance, auth guards, dependencies. Review specialists query it over MCP and attach the edges they used as evidence.
Learn moreTaint Analysis
Traces untrusted input to dangerous sinks — SQL, shell, file I/O — and writes CWE-tagged flows back into the graph as edges the security specialist can cite.
Learn moreAudit Proxy
Captures every agent decision — thinking blocks, narration, tool calls — as a structured event stream, so the review can see how the code came to be, not just what changed.
Learn moreSession Summarizer
Turns raw session events into structured summaries — key decisions, files changed, risks — condensing a long agent session into context a reviewer can act on.
Learn morePrompt Optimization
Evaluates summarization output, generates improved prompts, validates them against real data, and promotes the winners — so the context feeding review keeps getting sharper.
Learn moreReady when your IdP is
Built for teams where data residency, identity, and auditability are decided before the first review runs.
Self-hosted
Your cloud, your models, your keys. Docker Compose or Helm, with HPA out of the box and KEDA queue-depth scaling when you want it. Postgres is the only hard dependency.
Identity that scales
Keycloak OIDC with SPA PKCE; the API validates JWTs, so there are no sticky sessions. MFA and federated SSO — Entra, Google, Okta — are configured in your IdP, with zero Codesteward code changes.
Multi-tenant orgs
Members, connectors, policy, and learning are scoped per org, with SCIM 2.0 provisioning and a per-org bearer token when you need directory sync.
Bring your own models
OpenAI, Anthropic, xAI, OpenRouter, LiteLLM, or any OpenAI-compatible endpoint including local Ollama. Route a strong model to the judge and a cheap one to the generalist.
Used by engineers at
Compose on your laptop. Helm in your cluster.
The same stack either way: Postgres, the Graph MCP server, the API, workers, the UI, and a Codesteward-themed Keycloak.
Docker Compose
Full stack on one machine
# Point it at a model provider
export OPENAI_API_KEY=sk-...
# Bring up the whole category stack
docker compose \
-f deploy/compose/docker-compose.category.yml \
up --build -d
# UI → http://localhost:8080
# API → http://localhost:8081
# IdP → http://localhost:8083Helm
Kubernetes, with HPA out of the box
# Your Postgres and model keys
kubectl create secret generic codesteward-secrets \
--from-literal=databaseUrl=postgres://... \
--from-literal=openaiApiKey=sk-...
# Install the chart
helm upgrade --install codesteward \
./deploy/helm/codesteward \
--set worker.hpa.maxReplicas=20 \
--set worker.maxConcurrent=8Or try it in your own cloud — one click Evaluation
Spins up a single VM — NGINX edge with HTTPS, Keycloak, API, worker, UI, and Postgres — in your account, so you can kick the tyres in minutes. No model key at install; add providers in Settings → Models after you log in. It's meant for evaluation, not production — reach for Helm when you're ready to run it for real.
Give your review the context it has been missing.
Open source. Self-hosted. Apache-2.0.