openclawopenclaw
Your own personal AI assistant. Any OS. Any Platform. The lobster way. 🦞
- Language
- TypeScript
- Stars
- 381k
- Files
- 13k files
CODEBASE INTELLIGENCE FOR THE AI ERA · OPEN SOURCE · SELF-HOSTABLE
AI velocity that compounds
instead of collapsing.
AI gains collapse for three reasons: agents guess at context, humans re-review everything, and teams forget why the code is the way it is. repowise fixes all three with a verified index of your codebase’s structure, history, and risk, served to agents over MCP and to your team as a living wiki.
Open source and used every day by solo developers, startup teams, and platform engineers at large organizations.
Star the repo on GitHub- GitHub stars
- 4.5kGitHub stars
- Repos indexed
- 5.0kRepos indexed
- MCP tools
- 10MCP tools
- Incremental update
- <30sIncremental update
-96%tokens to load context
2,391 vs 64,039 on the same task. ~27x fewer. Answer quality at parity.
2.3xmore defects caught per review
vs a leading commercial tool under the same review budget, same 2,770 files.
0.74cross-project ROC AUC
The only code-health score validated against real defects. Up to 0.90 per repo.
Measured on real repositories. Every number is reproducible on your own codebase. Read the case study
WHY AI VELOCITY COLLAPSESThe gains don’t leak in one place.
The gains don’t leak in one place.
They leak in three.
Roughly ~42% of new code is AI-written in 2026, and the first quarter with agents feels fast. Then the same three knowledge gaps quietly claw the speed back.
01
Agents guess.
Your agent greps, reads three files, and confidently changes a function 47 callers depend on. It didn't know; nothing told it. Every wrong guess is a review cycle, a revert, a redo.
~1.7xmore issues in AI-written code than human-written
02
Humans re-verify.
The AI writes the diff in seconds; your senior engineers spend the afternoon rebuilding enough context to judge it. Generation got fast. Confidence didn't. Review became the bottleneck.
03
Teams forget.
The retry logic is shaped that way because of an outage two years ago. The engineer who knew that left. Last week an agent “simplified” it. Nobody caught it until it mattered.
None of these are model problems. They’re knowledge problems. A bigger model won’t fix them. A better-known codebase will.
ONE INDEX, THREE FIXES
Index the repo once.
Close all three.
The same index serves your agents over MCP and your team as a wiki, a health score, and a decision record. One pass, kept current on every commit.
FIX 01
Context agents can act on
Give agents the indexed graph, decisions, and health up front and they stop reading three files and hoping. Ten MCP tools, plus a CLAUDE.md generated from the real index.
-96%tokens to load context vs raw file exploration
How agents read the indexFIX 02
Docs your team can trust
A verified wiki and a defect-validated health score let reviewers judge a change without rebuilding the context by hand. The PR bot posts the same intelligence on every pull request.
0.74ROC AUC, health validated against real defects
How health is scoredFIX 03
Decisions nobody re-breaks
Captured decisions stay attached to the files they govern, so an agent or a new hire sees the reason before changing it. Commits are attributed to the agents that wrote them.
How decisions are capturedINTELLIGENCE LAYERS
Most tools answer one question.
repowise answers five.
Graph structure, code health, git history, generated documentation, and architectural decisions: five layers that compound into genuine understanding.
GRAPH
Every dependency, ranked and traced
- Tree-sitter ASTs across 10+ languages → directed dependency graph
- PageRank and betweenness centrality surface critical symbols
- Edge types: imports, calls, inherits, implements, co-changes
- Scales to 30K+ nodes with automatic SQLite-backed graph
CODE HEALTH
It knows which file breaks next, before it does
- State-of-the-art accuracy: ~73% at calling which files are headed for a bug, matching or beating the best commercial tools on the same real defects.
- One 1–10 score from 21 deterministic signals: complexity, hidden coupling, missing tests, churn, fragile ownership. No LLM, no cloud, under 30 seconds on a 3,000-file repo.
- Weights learned from a real defect corpus, not hand-tuned: it beats recency and past-breakage heuristics by 10+ points, and matches published academic models on unseen benchmarks.
- Three co-equal views per file: defect risk, maintainability, and static performance risk (N+1 and IO-in-loop shapes), never blended into one number.
- Ranks what to fix first by impact-for-effort and alerts when a file's health slips. A worklist, not an auto-refactor: repowise explains, it never rewrites.
payments/processor.py⚠ LIKELY TO BREAK NEXT
3.1/ 10 health
brain methoduntested hotspotchurn 96%ile3 owners
auth/middleware.py
4.6
api/routes.py
7.2
core/models.py
8.9
~73%state-of-the-art accuracy at calling the file a bug lands in
proven on 21 real projects across 9 languages
proven on 21 real projects across 9 languages
GIT
History that writes the documentation
- Hotspot detection: top 25% churn + complexity files flagged
- Co-change partners: files that change together without imports
- Ownership from git blame: primary owner + top 3 contributors
- Significant commits filtered into generation prompts
DOCS
Wiki pages that stay fresh
- 9-level hierarchical generation: symbols → files → modules → repo
- Confidence scoring with git-informed decay, so stale pages auto-regenerate
- RAG context via LanceDB or pgvector, so each page knows its imports
- Resumable, crash-safe, idempotent, with a checkpoint after every page
DECISIONS
The why behind your architecture
- 4 capture sources: inline markers, git archaeology, README mining, CLI
- Staleness tracking: decisions age when governed files get commits
- get_why() searches decisions before you change anything
- Health dashboard: stale decisions, ungoverned hotspots, proposed reviews
On every pull request
The index, delivered where the decision actually happens.
Install the GitHub App and the same graph and history behind everything above shows up in review: which contracts a pull request changed and who calls them, what it should have touched and did not, and a Check Run that can gate the merge. A green PR gets no comment at all.
What it found on one real pull request, which you can open and check:
- 9
- callers outside the PR of a contract it changed
- 4
- files that usually change alongside, missing from the PR
- 0
- LLM calls, so the same diff always reviews the same way
Public, no sign-in, on a repository you have never seen.
FOR ENTERPRISE
Self-hosted, air-gapped, commercially licensed.
Everything in repowise, deployed inside your firewall, with the identity, licensing, and compliance controls procurement asks for.
See the full enterprise brief- On-prem and air-gapped
- Run the whole platform inside your network. Zero telemetry, no phone-home, BYO LLM or fully offline via Ollama.
- Commercial license
- Removes the AGPL obligation and grants proprietary modification and embedding rights, plus IP indemnification and a defensive patent grant.
- Identity and access
- SAML and OIDC SSO with SCIM provisioning. RBAC and multi-tenant deployment are on the roadmap.
- Scale and support
- Reference HA topology, custom language and framework extensions, and priority support with an SLA.
Deterministic scoring with zero LLM in the loop, so EU AI Act high-risk obligations do not apply. Security and compliance
WHERE YOU FIT
One index, three ways in.
Developers
Give Claude Code, Cursor, and any MCP client a queryable model of your repo.
- Free and self-hosted, no key for the first index
- Ten MCP tools in every agent session
- Pro at $15/mo when you want hosted
Teams
One shared index, one credit pool, one org install. The whole team on the same brain.
- Review AI output without rebuilding context
- Portfolio health, ownership, and bus factor
- $20/seat/mo, 3-seat minimum
Enterprise
SALES-LEDSelf-hosted, air-gapped, and commercially licensed for the whole org.
- On-prem, private cloud, or fully air-gapped
- Commercial license with IP indemnification
- SSO and SCIM, priority support with an SLA
HOW IT WORKS
One engine, three interfaces
Install once. Choose the interface that fits your workflow, or use all three. They share the same data, the same intelligence, the same stores.
GETTING STARTED
CLI
For the solo developer
Read the install guide→$ pip install repowise
$ repowise init .
$ repowise update
$ repowise serve
MCP Server
For AI-native workflows
See the tools an agent gets→repowise mcp
get_overview()
get_context(["src/auth"])
get_risk(["payments.py"])
Web UI
For the whole team
Browse a live one→$ repowise serve
$ localhost:7337/wiki
$ localhost:7337/graph
$ localhost:7337/hotspots
HOW WE COMPARE
The full picture, side by side
- Auto-generated docs, git intelligence, decision records, and MCP tools, all in one package
- Open-source (AGPL-3.0) and fully self-hostable
- 17/17 features vs 4-6/17 for any single competitor
Scroll the table sideways to see every tool.
| Feature | repowise | Google Code Wiki | DeepWiki | CodeScene | Sourcegraph |
|---|---|---|---|---|---|
| Self-hostable OSS | ✓Included | –Not included | –Not included | –Not included | –Not included |
| Architectural decision records | ✓Included | –Not included | –Not included | –Not included | –Not included |
| MCP server for AI agents | ✓Included | –Not included | –Not included | –Not included | –Not included |
| Doc freshness / confidence scoring | ✓Included | –Not included | –Not included | –Not included | –Not included |
| AI code provenance (agent attribution) | ✓Included | –Not included | –Not included | –Not included | –Not included |
repowise: 17/17 · Google Code Wiki: 4/17 · DeepWiki: 5/17 · CodeScene: 6/17 · Sourcegraph: 4/17
Self-assessed against publicly documented features as of May 2026. Vendor capabilities change, so please verify before committing to any tool.
FREQUENTLY ASKED
Questions, answered
What is repowise?
repowise is a codebase intelligence layer for the AI era. It indexes your repo once and serves both your AI coding agents (an architecture-aware wiki, dependency graph, decisions, and ten MCP tools) and the humans accountable for the code (a defect-validated code-health score, change risk, git intelligence, and agent provenance). It is open source and self-hostable.
What does "AI velocity that compounds instead of collapsing" mean?
Coding agents make teams fast at first, but those gains erode when agents guess at context, humans re-review every change, and the team forgets why the code is shaped the way it is. repowise indexes your repo once and serves that knowledge (architecture, decisions, health, and risk) to agents over MCP and to people as a verified wiki, so speed keeps building instead of decaying. Every answer is checked against the live tree or flagged as stale.
Is repowise free and open source?
Yes. The core engine is open source under AGPL-3.0 and runs 100% locally: pip install repowise, bring your own API key, or run fully offline with a local model. There are paid hosted tiers for teams that want zero-ops hosting, private-repo PR comments, and managed re-indexing.
Which AI agents and editors does it work with?
repowise exposes your codebase over the Model Context Protocol, so it works with Claude Code, Cursor, Cline, and Codex, plus any other MCP-compatible client. One index serves every agent.
How much does repowise reduce my agent's token usage?
On paired benchmarks on real repositories, loading context through repowise used 96% fewer tokens (2,391 vs 64,039, about 27 times fewer), with 89% fewer file reads and 70% fewer tool calls, at answer quality on par with raw file exploration.
Does my source code leave my machine?
No. repowise is self-hosted with zero telemetry. Source is processed transiently and never persisted, and you can bring your own LLM key or run fully offline via a local model. What is stored is the graph, non-reversible embeddings, generated wiki pages, and git metadata.
Does the code-health score actually predict bugs?
Yes, and it is validated. Across 21 repos and 9 languages the cross-project ROC AUC is 0.74 (up to 0.90 per repo), and ranking by repowise health surfaces 2.3x the defects of a leading commercial tool under the same review budget. Every heuristic is open source so you can reproduce it on your own repo.
Which languages are supported?
Fifteen languages across the headline tiers, with full pipeline depth for Python, TypeScript, JavaScript, Java, Kotlin, Go, Rust, C++, and C#, including framework-aware route-to-handler edges for the major web frameworks.
How does repowise stay up to date as I keep committing?
It updates incrementally. A post-commit hook, file watcher, or webhook re-indexes only what changed, typically a handful of wiki pages in seconds, and every MCP response carries a staleness envelope that warns when the index has diverged from HEAD.
What is the difference between repowise and CodeScene?
repowise is an open-source (AGPL-3.0) alternative to CodeScene. Both analyze git history for hotspots and code health, but repowise adds a defect-validated health score (ROC AUC 0.74 across 21 repos), an LLM-generated architecture wiki, ten MCP tools for AI agents, and dead code detection. repowise is self-hostable at no cost; CodeScene is closed-source and enterprise-priced.
How do I generate a CLAUDE.md file for my repository?
Run 'repowise init' in your project root. repowise indexes the repo's AST, dependency graph, git history, and architecture, then generates a CLAUDE.md file that gives Claude Code, Cursor, and other AI coding agents immediate orientation: tech stack, entry points, hotspot files, ownership, and key design decisions. The file updates incrementally on every commit.
Does repowise review pull requests?
Yes. The Repowise PR Bot is a free GitHub App that posts one deterministic comment per pull request: the contracts the PR changed and every caller of them outside the PR, the tests and co-change partners it should have touched but did not, and a Check Run that can gate the merge. It calls no language model, so the same diff always produces the same review. Free and uncapped for public repositories.
What is git hotspot analysis?
Git hotspot analysis identifies files that are both frequently changed (high churn) and structurally complex. The intersection of churn and complexity marks the files most likely to contain defects and be expensive to modify. repowise computes hotspots from commit history and displays them with health scores, owner attribution, and blast-radius estimates.
FROM THE BLOG
Guides, comparisons, and deep dives
repowise
use-cases10 min read
Case Study: We Build repowise With repowise
repowise is developed against an index of itself: every pull request is gated by the same risk and health checks we ship. The setup, measurements, and limits.
repowise
guides8 min read
CLAUDE.md & AGENTS.md: The Complete Guide
What CLAUDE.md and AGENTS.md are, what to put in them, best practices, and how to keep them fresh automatically. Learn to give coding agents real repo context.
repowise
guides9 min read
Code Health: The Complete Guide (2026)
Code health is a defect-validated measure of how risky code is to change, scored from 49 deterministic markers across three pillars. Reproduce it on your repo.
The agents will keep getting faster.
Make it compound.
Or book a 30-minute demo with usGET IN TOUCH
Three paths to codebase intelligence
- Self-host, free forever
pip install repowiseon your machine, your server, or your CI- AGPL-3.0, full feature set, code never leaves your infra
- Hosted SaaS — live now
- Managed indexing, team workspaces, semantic chat
- Pro at $15/mo with LLM credits included, or start free with two public repos
- Working as a team? One shared brain for everyone, $20/seat/mo
- Enterprise
- On-prem, private cloud, or air-gapped, with SSO, a commercial license, and priority support with an SLA
- Book a demo or read the enterprise brief
