Give every engineer an agent that actually understands your codebase.
Index your repos once, and every developer’s AI agent — Cursor, Claude Code, Copilot — works from the same real map of your code: a queryable call graph, semantic search, and a shared memory of past decisions. New hires get productive in days, not weeks. Changes get checked against real callers before they ship. And your source never leaves your network — not a SaaS that ingests your repo, infrastructure you control.
What it changes for the business.
The same local-first engine your developers love — read as outcomes the people signing the contract care about. Sharper delivery on critical software, with the cost and risk you can actually predict.
New hires ship in days, not weeks
A new engineer points their agent at an unfamiliar repo and asks — in plain language — “where does billing get retried?”. The agent answers from the real call graph instead of grepping blind. The codebase explains itself, so ramp-up stops depending on whoever wrote it being free to pair.
Catch the blast radius before it ships
“What breaks if I change this?” is answered from actual callers — across files, across repos, across REST / gRPC / queue seams — and scored high, medium or low before the diff lands. The bug your team finds in code review instead of in production is the cheapest bug you’ll ever fix.
Stop paying the rediscovery tax
Out of the box, an agent rebuilds context every prompt — grep, re-read, infer, burn tokens, repeat. codeindexer hands it precise context in one indexed query instead of a dozen blind greps, so your agent spend buys reasoning, not re-reading the same files.
One source of truth, every seat
Decisions, gotchas, fixes and roadmaps live in a shared memory every developer’s agent reads. A junior queries the same graph and the same institutional knowledge as your staff engineer — quality stops being a function of who happens to be online.
One index. Every developer queries the same graph.
No magic, no integration project. The whole thing is three steps, and your engineers keep the editor and AI client they already use.
Deploy once, inside your network
A single Rust binary on your own hardware or a shared volume. No cloud, no data plane in our infrastructure, no API key. Indexing, search and audit run entirely on machines you control — works fully offline in air-gapped environments.
Index your repos into one shared graph
A 200k-line repo indexes in 1–3 minutes; after that only changed files re-index, under a second on save. Index once, centrally — every developer queries the same call graph and the same memory instead of each rebuilding context alone.
Every engineer connects their AI client
Each developer wires their agent — Cursor, Claude Code, Copilot, Windsurf — to the shared server over MCP, the open standard for AI tooling. Per-key access scoping keeps contractors to the projects they should see. No new workflow to learn; their existing agent just gets a lot smarter.
>_ The result: a senior’s mental model of the codebase, available to every agent on the team — on day one.
Built for procurement, security, and scale.
Direct line to engineering
You talk to the engineers who wrote the parser. Integration support up to and including on-site help when scope justifies it. No tiered ticket triage, no bot replies, no “account manager” layer.
Custom parsers and connectors
Internal DSL, legacy COBOL or PL/SQL, proprietary bytecode, niche document formats, custom log structures — we add support as a first-class codeindexer tool, shipped to your team and maintained by us.
Large-corpus support
Index more than just source: internal documentation, runbooks, ticket archives, chat logs, knowledge bases, archived datasets. Tuned for multi-million-document corpora when your stack needs it.
Documentation your security team expects
GDPR DPA, Sub-processors list, Security policy, SLA, disclosure pipeline — all published openly. No long lead times before procurement and security can review you.
When it matters, you reach an engineer.
Reliability isn't a status page — it's who picks up when something breaks. With Enterprise, that's the team that built it.
A named engineer, not a ticket queue
You get a direct line to the people who wrote the parser. No tiered triage, no bot replies, no account-manager layer standing between you and a fix. On-site help when the scope justifies it.
4-hour critical response SLA
Critical issues get a response within four hours. The full severity matrix — response and resolution targets per tier — is published openly so procurement can review it before you sign.
Security patches within 7 days
Disclosed vulnerabilities are patched within 7 days; a failing dependency audit blocks our release pipeline. Every binary is signed and notarised on macOS, Windows and Linux.
Advance advisories under embargo
Enterprise customers receive security advisories ahead of public disclosure when the issue warrants it — time to patch your fleet before anything goes public.
Full response & resolution targets per severity tier: read the SLA.
Runs where your code already lives.
No data plane in our cloud to leak, breach, or subpoena — because there isn't one. You decide where it runs and who can reach it.
On-prem, on your terms
Deploy on your own hardware with custom license terms. Indexing, search and audit run entirely inside your network — nothing phones home.
Zero external calls
Embedding and reranker models ship inside the binary. Index and audit in fully offline, restricted environments — no internet egress required.
Shared indexes, one source of truth
Team-wide indexes on a shared volume with bearer-token auth and a CORS allow-list. Index once; every developer queries the same graph.
Per-key project access control
Each API key is scoped to the projects it may touch — contractors and teams see only what they should.
Per-developer identity, shared data
Cards, reports and history are attributable to a developer even on a shared index — accountability without silos.
Your code stays your code.
Local execution
codeindexer runs entirely on your machine. Indexing, embedding, search, audit — everything happens on localhost. The server binds to 127.0.0.1 by default. No source code, no file contents, and no search queries are sent to our servers, ever.
What we do see
Pro and Enterprise licenses make one HTTPS call per day to verify the license. That request contains a license ID and an anonymous machine fingerprint — nothing else. The exact payload is auditable in our open documentation. If the license server is unreachable, the binary continues normally for a 14-day grace window.
Hardening
HTTP transport supports bearer-token authentication, configurable CORS allow-list, and same-origin protection out of the box. Stdio transport is process-level isolated. Index data lives in your user data directory with restricted permissions. License files are stored with 0600 mode on Unix.
Four hard questions, answered straight.
The questions a good CTO asks before letting a new tool anywhere near the team. Here are ours — answered the way we’d want them answered.
Commoditization
“Won’t Cursor and Copilot just build this in?”
They’re building retrieval — inside their own walls.
- A built-in index belongs to the tool, not to you. Switch IDE, model or vendor and your context stays behind. codeindexer sits a layer above your tools — move from Claude to Gemini to a local model and keep the graph, the search, the memory.
- An IDE vendor profits from lock-in, so portable context is the one feature they won’t ship. Building on an open standard (MCP) is the opposite bet.
- Built-in retrieval is embedding search. A cross-language call graph, blast radius, persistent memory and a security audit are a different category of tool.
- And if they do catch up? You’ve lost nothing — see the next card.
Dependency risk
“Isn’t this another dependency we can’t see into?”
It never enters your dependency tree.
-
Not in
package.json, not inCargo.toml, not in CI, not in production. Your build — and your users — cannot be affected by it. - Everything it produces is plain files on your disk: the index, the embeddings, the memory. Inspect them, back them up, delete them.
- The Free tier makes no network calls at all — there’s nothing to audit on the wire.
-
Switching it off tomorrow costs you convenience, not a broken build. Uninstall is
rm, not a migration project.
Knowledge ownership
“Shouldn’t our decisions live in our repo, not in a tool?”
They do. That’s the design.
- Memory is files on your machine — and decisions, cards and reports export to plain markdown you can commit right next to your code.
- The index is derived data. Your repo stays the single source of truth; codeindexer just makes it queryable for the agent.
- It’s memory for the agent, not a replacement for your docs — the agent reads it so your team stops re-explaining the architecture every session.
The honest one
“Do we actually need it?”
Maybe not. Honestly.
- Small repo, one AI client, an agent that never gets lost, nobody re-solving solved problems? Skip it — you’re fine.
- It starts paying when the codebase outgrows the context window, the agent greps in circles and re-reads the same files, you run more than one AI tool or model, or the same architecture gets re-explained every week.
- Free for 3 projects, no card, no cloud — the cheapest way to find out is to point it at your gnarliest repo for a day.
One contract. Every team. Every workflow.
Enterprise
Custom — annual contract, invoiced. Scoped per deployment model and seat count.
- Everything in Pro, unlimited seats
- Custom parsers and connectors built for your stack
- Large-corpus support — source code, docs, tickets, chat
- Personal integration support — direct line to engineering, on-site when justified
- On-premise / self-hosted deployment with custom license terms
- Procurement-ready — DPA, Sub-processors, SLA, Security disclosure published openly
- SLA with 4-hour critical response (full matrix on /sla)
For technical due diligence.
VC firms and technical advisors run Code Indexer on portfolio repos to get architecture overview, dependency risk, dead-code maps, documentation coverage, and complexity hotspots in minutes — fully self-hosted, no source code leaves the founder's machine.
Same product, same audit pipeline, different reader. Useful for: pre-investment technical assessments, post-acquisition integration audits, periodic portfolio health checks.
Teams using codeindexer.
Bohemia Automation
EVA ICS® automation platform — industrial control, connectivity and security stack
Stewopol MS M. Leshchanka sp. k.
Wholesale of electronic and telecommunications equipment
Merge Tech FZE
Custom software solutions · since 2019
AR CONNECT s.r.o.
B2B IT services & consulting · 10+ years
Let's scope your deployment.
Tell us your stack, your seat count, and your deployment model — self-hosted, air-gapped, or shared. We'll come back with a concrete proposal, not a sales funnel.