Understand

Find stuff fast, even if you don’t
know what it’s called.

RepoQL gives your agent a map of the code and precise ways to read it. It can learn the local vocabulary, follow the implementation, and bring you back an explanation with sources you can check.

Your laptop

An authentication investigation: from unfamiliar names to the validation boundary, then a lesson captured for future work. Follow the workflow →

Remember why

The next agent should know
what this one learned.

The constraint you uncovered. The reason a design looks unusual. The regression you never want to see again. That understanding belongs with the code, where it can guide the next change.

.repoql/concepts/rule/ConfigurationMigration.md

Example · a fictional codebase

Capsule: ConfigurationMigration

Invariant

MyConfig is still in use but deprecated. Use MyNewConfig instead.

Why

MyNewConfig validates typed settings at startup, so missing or invalid values are caught before requests arrive. MyConfig remains for callers that haven’t migrated; adding new callers prolongs the migration.

Example

For a new retry timeout, add a typed setting to MyNewConfig rather than another string-key lookup through MyConfig.

Depth

Preserve configuration keys and defaults when migrating an existing caller.
Remove MyConfig only after its last caller has migrated.

Relevance

src/config/MyConfig.cssrc/config/MyNewConfig.cs

Verification

file:///src/config/MyConfig.cs;file:///src/config/MyNewConfig.cs;file:///src/**/*.cs;file:///tests/config/**/*Migration*.cs

During the investigation

Your agent captures the understanding.

It records why both systems exist, which one to use, and the evidence for that decision. RepoQL fact-checks the claim against the supplied evidence and saves the concept as Markdown.

During the next change

Touch either implementation. Find the same guidance.

The concept’s relevance covers both configuration implementations. An agent touching MyConfig or MyNewConfig finds the same guidance, so discovering the old code doesn’t send it down the old path.

As the code evolves

Finishing the migration makes this concept stale.

Once the last MyConfig caller is migrated, “MyConfig is still in use” stops being true. RepoQL’s periodic revalidation checks the evidence and flags the concept for an agent or maintainer to update or remove.

Concepts are files you own, with reasons your team can read. Commit them with the repository so other sessions and teammates inherit them. How concepts work →

Follow the connections

Your system is bigger
than one checkout.

Your company buys another product. Now you need to make it work with yours. Both have customers, permissions, and billing, with different assumptions about how they fit together.

Changing an event contract in one repository can break a service downstream. Let your agent trace those consequences across the system before they become an outage.

Bring those sources into RepoQL and your agent can investigate across them. Understand how both systems work before deciding where to connect them. Code, documents, git history, and telemetry become information it can search and query together.

Bring another repository into reach →

The same tools reach your local code, imported sources, and collected runtime evidence.

Uplink

Give the team access
to the same understanding.

You don’t always have a checkout and a local RepoQL host to hand. A product manager asking “what if we changed this?” from their phone. A code review agent tracing downstream consequences. A Slack bot answering questions about your system.

Uplink gives those agents access to a shared index of your repositories, dependencies, and captured knowledge. Run the host on your infrastructure and connect the agents wherever they’re used.

The host connects out through a secure tunnel; authorised agents reach it through a remote MCP endpoint. No inbound port to open, no VPN to join.

How uplink works →

Your repositories and index stay on your host. Uplink relays authorised tool requests and results between the host and your agents.

Review with understanding

A small diff can have
a long reach.

Give a reviewing agent the concepts for the changed files, then let it follow the consequences into other repositories. It can assess the change against each repository’s requirements and explain the reason behind a finding.

Illustrative reviewFictional repositories

The change · events-api

Generate a new delivery ID on each retry.

The retry code changes in one repository.

The consumer · billing-worker

Use the delivery ID to recognise an event already handled.

The duplicate check lives in another.

The repository’s rule

A redelivered event must not create another invoice.

A captured concept explains the requirement.

What the reviewer can explain

This retry could create a second invoice.

The billing worker uses the delivery ID to recognise events it has already processed. A new ID makes the retry look like a new event, so it can pass the duplicate check and create another invoice.

Keep the ID stable across retries, or update the consumer’s duplicate detection as part of the change.

Changed behaviourDownstream consumerRepository requirement

Build this workflow with RepoQL today. Its concept, code, and cross-repository tools are available to your agents.

The knowledge behind the review →

Start with your own code

Bring a question you already care about.

Install RepoQL, connect the agent you use, and open a repository. The local index builds on demand. Ask about something you need to understand before your next change.

Try asking your agent

“Use RepoQL to investigate the change I’m about to make. What depends on this behaviour, and what repository guidance should I follow? Show me the evidence.”

Describe your change and the area you’re working in. Judge the answer by the code it finds, the reasons it uncovers, and what you can verify.

By downloading and using RepoQL, you agree to the Customer Terms and Software Licence.

$ curl -fsSL https://downloads.repoql.ai/latest/install-rql.sh | bash

no sudo · installs to ~/.local/bin · asks before wiring your agents · read it first

$ brew install repoql/tap/rql

macOS & Linux · updates via brew upgrade rql · run rql install to wire your agents · view the tap

> irm https://downloads.repoql.ai/latest/install-rql.ps1 | iex

no admin · installs to %LOCALAPPDATA%\rql · asks before wiring your agents · read it first

Your existing agent

The installer connects RepoQL to Claude Code, Codex, Cursor, Copilot, and other supported agents.

Setup instructions →

A free local engine

Index, search, and read code on your machine. Paid plans add cloud capabilities and more reach.

Compare plans →

Clear data boundaries

The index lives on your host. Cloud features process selected content; the data guide explains what leaves and when.

Read the data guide →

Find stuff fast, even if you don’t know what it’s called.

The next agent should know what this one learned.