AG.IDE turns code quality into a self-improving loop. It indexes your whole repository locally, ranks the worst code, and gives your AI coding agent the context to fix it — not pile on more slop. Runs offline, and makes cheap local models like Qwen punch far above their weight.
AG.IDE treats your repository like a living system, not a stream of diffs. Every pass surfaces the next high-leverage improvement.
Map the repo: files, symbols, calls, history, duplicates, and quality signals.
Rank the refactoring opportunities that matter most: complexity, coupling, churn, side effects, and ambiguity.
Give the target and its context to your coding agent so it can make a focused improvement.
Run the cycle again. Each pass re-scores the repo, reveals the next best target, and keeps code quality climbing.
AG.IDE runs entirely on your hardware. No cloud API calls, no up source to a review queue, no feeding your codebase into someone else's training pipeline. Every capability ships with the binary.
No passwords leaked, no proprietary logic uploaded, no one else getting rich off your source. AG.IDE makes zero outbound connections to analyze your codebase.
Proprietary code-quality models, structural clustering for coupling analysis, near-duplicate compression — all in the binary. No external AI API. No dependency that calls home.
Written in Rust. GPU-accelerated from the UI layer to the analytics engine — models included. Runs as fast as your hardware allows.
Reason about code larger than any context window. AG.IDE maintains the full structural picture of your codebase — call graphs, coupling maps, impact radius, quality signals — so your coding agent always knows where it stands, what it's touching, and what breaks if it moves.
Grep finds string matches. AG.IDE finds the problem. Classic code smells and structural coupling patterns are invisible to search-and-replace coding agents — they only emerge when you can see the whole.
Before touching anything, see everything it affects. Callers, callees, downstream dependents. Your agent plans its move like an engineer who's been burned before.
The codebase never fits in context. The right target, with the right surrounding context, always does. AG.IDE compresses the whole into exactly what the model needs.
AG.IDE — Cobra overview · dark theme · combined quality ranking
PRs were made for humans. AG.IDE is made for what's next.
Diffs can't see drift. A pull request shows you 200 changed lines — not that the system is now 3% more coupled, or missing the abstraction that would have made the last four PRs unnecessary. At agent throughput, nobody reads 50 PRs a day. CI runs. Comments accrue. The codebase drifts anyway.
| PR workflow | AG.IDE | |
|---|---|---|
| Unit of review | One diff. Yesterday's commits are invisible the moment they merge. | The whole codebase. Every function, every commit, continuously re-ranked. |
| Cadence | Per change. A human opens a PR. The tool comments. Nothing else moves. | Continuous. No trigger, no queue, no inbox. |
| What it catches | Bugs in new code. Coupling that crept in over 50 commits — invisible. | Drift in existing code. Code smells and coupling patterns only visible at scale. |
| Scales with | Human reading speed. At 50+ agent PRs a day, nobody is keeping up. | Indexing throughput. Runs as fast as your hardware allows. |
| Refactors | Rarely. Out of scope. That's next sprint's problem. | Continuously. It's the job. |
There's already one loop: write, review, merge. AG.IDE is the second loop — index, rank, refactor. Complementary cadences, one codebase.
If your team's output tripled this year and your codebase feels worse than it did in January, you are not imagining it. Technical debt used to accumulate in months. With coding agents, it accumulates in days. Models optimize locally — one function at a time, blind to the system around it. Nobody is doing the refactoring pass that used to follow. The debt compounds in silence, and there is no PR that surfaces it.
Agents write good individual functions. They can't see that those functions are pulling the system apart. Coupling grows. Duplication spreads. The architecture drifts — commit by commit, silently.
Deliberate refactoring — the kind that keeps a codebase coherent — requires seeing the whole. No agent in your current workflow does this. So the pass doesn't happen, and the debt compounds.
Continuous refactoring, automated. AG.IDE finds the worst technical debt, gives your agent the context to fix it, and loops. The debt gets paid down while you ship features.
AG.IDE — Cobra getCompletions · code heatmap
A macOS app, or a single Linux binary. No account, no signup. Run it on a repo and walk away.
curl -fsSL https://agide.dev/install.sh | bash
Installs the agide
CLI + embedding model to ~/.agide
. Runs offline.