Kensa runs the specialist AI review agents you configure in parallel on your desktop and grades every finding so you can decide fast.
The review runs on your machine, and you watch it happen: findings land while the other agents are still working, already graded with severity and reasoning.
Dramatization
Your agents — the built-in engineering preset or a lineup you define — run in parallel and return structured findings, not a wall of comments.
Pull request
fix: harden payment capture retries
Your agents · in parallel
Architecture
Boundaries, coupling, dependency direction
Security
Injection, secrets, authorization paths
Error Handling
Silent failures, retries, timeout paths
Structured findings
Dramatization — counts, identifiers and attributions are synthetic.
Point Kensa at any repo you already have — or browse and clone one in-app. Each repository keeps its own agent lineup and settings.
Add repository
Dramatization — synthetic data.
Pick a preset or define your own specialists: focus, keywords, file patterns, checklist. Route your skills. Choose the AI CLIs you already pay for.
Agent lineup
Dramatization — synthetic data.
Your agents dispatch in parallel on your machine. Watch findings stream in, already graded — or schedule the run and come back to it finished.
Review run
3 running · 1 queuedDramatization — synthetic data.
Every finding carries a written severity, its reasoning, and attribution. Publish to the PR without clobbering existing threads, or fix it in a one-click worktree.
src/services/payments.service.ts:128
A rejected capture inside the retry drain is silently dropped — the operator never learns the charge failed.
Dramatization — synthetic data.
One dropped error in a payments retry. On the left, the shape a review comment usually takes. On the right, the same defect as Kensa files it.
A comment
Consider adding error handling here.
No grade. No evidence. No author.
A finding
src/services/payments.service.ts:128
A rejected capture inside the retry drain is silently dropped — the promise chain has no handler, so the operator never learns the charge failed.
- drain(() => capture(order))+ drain(() => capture(order).catch(report)) metrics.record('capture.retry')Everything below runs locally, against the AI providers you already pay for — on GitHub, GitLab, Bitbucket or Azure DevOps, with the tracker you already use.
Dramatization
Kensa indexes your repository locally and serves that map over MCP. The coding agent you already talk to can ask what calls what, and what a change touches, without leaving the terminal.
13 tools. Every one of them a read.
› what calls the retry drain?
⏺ trace_relationships("drain", callers)
⎿ 4 callers · depth ≤ 2 — bounded evidence, not a blast radius
› what does my branch touch?
⏺ get_pull_request_impact(a3f9c1…, 7d2e04…)
The engine runs on your desktop against your own provider CLIs. Code never touches a hosted runner. Cloud handles sign in and sync only.
Dramatization
Coming soon
Three instruments taking shape — each lands when it earns its way in.
Act on the review without leaving Kensa.
A GitKraken-caliber git client inside the app — commit graph, interactive rebase, conflict resolution.
Not a chatbot — a workspace you supervise.
A team of AI agents works in one place — chat, terminal, files and diffs — and you approve what matters.
The same review engine, in your terminal and CI.
Today Kensa speaks MCP. A standalone CLI is next.
Point it at a pull request — or at the changes you haven't pushed yet.
