Repowise

repowise is built for developers who want AI coding agents to understand a repository instead of repeatedly searching through the same files. It creates a reusable model of a codebase from its source structure, dependencies, Git history, engineering decisions, tests, and code-health signals, then makes that information available to AI agents through the Model Context Protocol (MCP).

The idea is refreshingly practical: index a repository once, keep the index current, and let an agent retrieve the context it actually needs. Instead of spending its context window rediscovering callers, dependencies, architectural decisions, or risky files, it can work from information that has already been organized for the task.

It can be used locally through its open-source distribution or through a hosted environment. The self-hosted approach keeps the indexing process on your own machine, while the hosted version adds managed indexing, private repositories, team collaboration, and additional security features.

Key Features

• Codebase indexing across source structure, dependencies, Git history, ownership, tests, and engineering decisions.
• MCP access that gives compatible AI coding agents reusable repository context.
• Dependency graphs for understanding relationships between files, symbols, and modules.
• Code-health scoring designed to identify problematic and potentially risky areas of a repository.
• Change-risk analysis for commits and pull requests.
• Automatically generated repository documentation and architecture information.
• Git intelligence for identifying hotspots, ownership patterns, hidden coupling, and bus-factor concerns.
• Dead-code detection to help teams locate code that may no longer be needed.
• Security capabilities including dependency vulnerability analysis and reachability-aware CVE triage on supported hosted plans.
• Support for multi-repository workspaces in team-oriented environments.

User Interface

The experience is centered around the repository rather than a complicated collection of disconnected dashboards. Developers can work from the command line, connect an AI coding agent through MCP, or use the hosted interface to explore indexed repositories and their underlying intelligence.

The local workflow is particularly straightforward. After installing the package, a developer can initialize a repository and let the system build its index. The resulting information can then be explored through repository documentation, dependency relationships, health signals, Git intelligence, and agent queries.

For teams, the hosted environment adds a more collaborative layer. Shared repositories, portfolio health, ownership information, cross-repository workspaces, and pull-request analysis make the product useful beyond the individual developer sitting in front of an IDE.

Accuracy & Performance

One of the strongest aspects of the approach is that many of the core signals are derived from repository evidence rather than being presented as an unexplained AI opinion. Code-health scores, dependency relationships, ownership information, Git history, and change-risk signals are tied back to the underlying codebase.

The published benchmark results are also worth noting. The product reports 0.876 file coverage in ContextBench, a 31.6% reduction in agent-loop output tokens in a published Codex benchmark, and a 0.74 defect-prediction ROC AUC across 21 repositories, 9 languages, and 2,826 files. These figures come with stated sample sizes and testing conditions, which makes them considerably more useful than a generic claim about being "faster."

For everyday development, the practical benefit is less about a flashy response and more about reducing repetitive repository exploration. An agent can retrieve symbols, callers, decisions, health signals, and documentation without repeatedly starting from raw source files.

Capabilities

The system builds a broad picture of a repository. Its intelligence layers cover static structure, Git history, generated documentation, architectural decisions, and code health. The parser supports a wide range of programming languages and also handles several configuration and data formats.

Developers can use this information to ask questions about how a feature works, discover what depends on a particular function, investigate potentially dangerous changes, locate dead code, examine architectural relationships, or understand which parts of a repository deserve attention before a refactor.

The MCP integration is especially useful for AI-assisted development. Rather than treating the entire repository as an unstructured prompt, an agent can retrieve focused information according to the task it is currently performing.

Security & Privacy

Privacy is an important part of the product's architecture. The self-hosted version can run entirely on infrastructure controlled by the developer, meaning the repository does not need to leave that environment for indexing.

For the hosted service, repository data is processed in an ephemeral indexing environment. The service states that the cloned working tree is removed after processing and that repository code is not used to train models. Hosted paid plans also provide security-oriented capabilities such as CVE-aware dependency scanning, function-level reachability analysis, secret detection across Git history, SBOM and VEX exports, and security audit trails depending on the plan.

Teams that require additional deployment control can also evaluate customer-managed and private-cloud or on-premise deployment options through the enterprise offering.

Use Cases

AI-assisted coding: Developers using Claude Code, Cursor, Codex, or another MCP-compatible coding agent can provide the agent with structured repository context instead of repeatedly asking it to search through the same project.

Large codebase onboarding: New engineers can use generated documentation, architecture information, symbol exploration, and repository relationships to understand an unfamiliar project faster.

Refactoring: Before changing a function or module, developers can investigate callers, dependencies, historical co-changes, test gaps, and potential blast radius.

Pull-request review: Teams can analyze changes against repository history and dependency relationships to identify risky modifications, changed contracts, and files that historically move together.

Code health management: Engineering teams can locate hotspots, dead code, maintainability problems, and files with higher defect risk instead of relying solely on intuition.

Documentation: Generated repository documentation can provide architecture and module-level explanations while remaining connected to the source that produced them.

Security analysis: Engineering and security teams can use dependency information and reachability analysis to determine whether vulnerable dependencies are actually relevant to the application's execution paths.

Pros and Cons

• Pros: Open-source core, self-hosting option, strong MCP integration, repository-aware AI context, dependency analysis, Git intelligence, code-health signals, dead-code detection, architecture documentation, and useful team features.
• Pros: The deterministic portions of the index do not require an LLM or API key, making it possible to build a useful repository model before adding model-powered features.
• Pros: Hosted plans provide private repositories, automatic synchronization, AI documentation, team workspaces, and security functionality.
• Cons: Some of the most advanced AI-powered capabilities are reserved for paid plans.
• Cons: Developers who prefer a completely managed experience may find the self-hosted workflow more technical than a conventional web-only coding assistant.
• Cons: The value becomes more apparent on projects with meaningful codebase complexity; very small repositories may not need the full range of analysis.

Pricing Plans

The hosted service currently has a Free plan at $0 per month, a Pro plan at $15 per month, a Teams plan starting at $60 per month for three seats, and an Enterprise option with custom pricing.

The Free plan is designed around public repositories and includes public repository indexing up to 250 MB, semantic search, a dependency graph, hotspot detection, dead-code analysis, ownership information, architectural decisions, symbol exploration, and 10 AI answers per month. It does not include private repository indexing, AI documentation generation, or unlimited AI answers.

The Pro plan costs $15 per month and adds support for repositories up to 5 GB, private repository indexing, full Git history, push-triggered synchronization, AI documentation, unlimited codebase chat and quick-ask, documentation coverage, and $5 of monthly LLM credits.

The Teams plan starts at $60 per month for three seats, with additional team-oriented capabilities such as shared repositories, pooled credits, a team-wide pull-request review bot, portfolio health, ownership intelligence, cross-repository workspaces, and Jira and Confluence integration.

Enterprise pricing is customized for organizations that need customer-managed deployment, private-cloud or on-premise operation, commercial agreements, support, or additional organizational requirements.

How to Use It

Getting started is relatively simple for developers comfortable with a command-line workflow. The local installation can be performed with Python's package manager, followed by initialization inside the repository that needs to be analyzed.

After installation, move into the project directory and initialize the repository. The system parses the project, builds its dependency graph, analyzes Git history, evaluates code health, identifies dead code, and creates repository documentation from the available structure.

Once the index is ready, developers can connect an MCP-compatible coding agent and allow it to query the repository intelligence. The same index can also be explored directly through the available commands and local dashboard.

For a hosted workflow, developers can sign in, connect a repository, and use the managed environment instead. This route is particularly convenient for teams that need private repository access, automatic synchronization, shared workspaces, or centralized collaboration.

Comparison with Similar Tools

Many developer tools focus on either code search, AI code generation, static analysis, or documentation. This product takes a broader route by connecting several of those concerns through one repository index.

Compared with a conventional AI coding assistant, the main distinction is the persistent repository context. The assistant remains responsible for writing and editing code, while the indexed intelligence provides information about the project around the code being changed.

Compared with traditional static-analysis software, the approach goes beyond individual warnings by combining structural relationships, Git history, architecture, ownership, documentation, and AI-agent context.

Compared with documentation-only tools, the generated material is connected to the underlying repository structure and can be refreshed as the code changes. That makes it more useful for living projects where documentation can otherwise become outdated quickly.

The result is particularly compelling for engineering teams that want AI-assisted development without giving up visibility into why an agent is making a recommendation or which parts of the repository support it.

Conclusion

For developers working with growing repositories, the hardest part of AI-assisted coding is often not generating code. It is giving the agent enough context to understand the code that already exists. This product tackles that problem by turning a repository into a reusable source of structural, historical, architectural, and health information.

The open-source core makes it accessible to developers who want to control their own environment, while the hosted plans extend the same foundation into private repositories, team workflows, automated synchronization, security analysis, and collaborative engineering intelligence.

If your development workflow increasingly involves AI agents, but you are tired of watching those agents repeatedly grep through the same codebase, this is a thoughtful tool to explore. Its biggest strength is not simply that it knows more about a repository; it is that the information is organized so both humans and AI agents can actually use it.

Frequently Asked Questions (FAQ)

What is this tool designed for?

It is designed to provide AI coding agents and developers with structured, reusable intelligence about software repositories, including dependencies, Git history, architecture, documentation, ownership, and code health.

Does it work with AI coding agents?

Yes. The platform exposes repository intelligence through the Model Context Protocol, allowing compatible AI coding agents to retrieve information from the indexed codebase.

Can I run it locally?

Yes. The core is open source under the AGPL-3.0 license and can be self-hosted. The local workflow is designed so the repository can remain on infrastructure controlled by the developer.

Do I need an API key to create the initial index?

No. The initial deterministic indexing process can be performed without an API key. Model-powered documentation and other AI features can be added later when required.

Does it support private repositories?

Yes. Private repository indexing is available through the paid hosted plans, using GitHub integration.

Does it generate documentation automatically?

Yes. Paid hosted plans include AI documentation generation, while the underlying repository structure can also be used to produce documentation from code intelligence.

Can it identify risky code changes?

Yes. Change-risk analysis considers information such as dependents, historical co-changes, ownership, test coverage gaps, and repository evidence to help identify changes that deserve closer attention.

Is there a free plan?

Yes. The hosted Free plan costs $0 per month and provides public repository indexing with a set of repository intelligence features and 10 AI answers per month.