Code review
Know what breaks before you approve
Ask the blast radius of the changed function and see every caller, across repos, with the tests that cover them.
Now live · Works with Cursor, Claude Code & Codex
Your AI agent is guessing.Symvanta makes it certain.
On a real codebase your agent greps blindly, invents functions that don't exist, and ships refactors that break things it never saw. Symvanta is the code knowledge graph it plugs into over MCP: who calls what, and what breaks if it changes, across every repo in your project.
One live graph across every repo in your project.
+47%
more correct answers on a 2M-line benchmark repo
15% fewer
tokens for the same answers
<5 min
to index a fresh 100k-line repo, zero setup
7-day trial, no credit card. See it on your own code in minutes.
Your agent reads files.
It never sees the graph.
When your agent reads raw files, it misses the graph: callers, dependencies, blast radius. Relationships that Symvanta pre-computes so agents never have to guess.
Without Symvanta
With Symvanta
Without Symvanta
Context limits
Can't fit a large codebase in context
Agent dumps whole files into context: 5k to 30k+ tokens per question, and it still hallucinates.
With Symvanta
Context limits
Graph pre-computes relationships
Agents retrieve only the relevant slice: 500 to 5k tokens of structured context.
Without Symvanta
Graph relationships
Misses callers, deps, blast radius
Raw file reads can't see who calls a function, what it depends on, or what breaks when it changes
With Symvanta
Graph relationships
All relationships pre-computed
Graph indexes calls, imports, and exposes edges before agents ask, retrieved in a single MCP call
Without Symvanta
Hallucination
Invents code that doesn't exist
Agents confidently reference functions, modules, and paths that do not exist in your actual codebase
With Symvanta
Hallucination
Grounded in the real symbol table
Every answer resolved against a live graph of your actual code, no invented functions, no phantom imports
Without Symvanta
Repo boundaries
Context stops at the repo wall
A signature change in a shared library silently breaks consumers in other repos the agent never opened
With Symvanta
Repo boundaries
Linked repositories share one graph
Import and HTTP-call edges cross repo boundaries, so blast radius includes the other repo's callers
See it on real code.
No signup required.
This is cal.com and trpc, two public repositories indexed live in Symvanta. Every answer below is real. Click a question, then verify any line on GitHub.
Symvanta on cal.com+ trpc
cal.com@561cf88 · trpc@3e0e979 · indexed from HEAD
17,230files
41,580symbols
409,745relationships
wide blast radius: 10 files across 4 packages
+ 5 more: the DI container, the IBookingCancelService interface, and 2 test suites
Four packages, three layers: the tRPC handler, the calendar sync, and the DI module all break. A grep for the symbol name finds none of them. The graph follows the edges.
Every result above is a real index of a public repo. Verify any line on GitHub.Connect your repo →
Same question.
Night and day difference.
Ask your agent to review PR #412, which changes UserService.delete. Here is what each one does.
git diff → users/service.ts (+12 -3)
grep -rn "UserService" src/
→ 23 matches, read 7 files · 16,400 tokens
Diff adds a soft-delete flag. Only
AdminController calls delete, and it has
a test. Looks low-risk.
LGTM, approving. (skipped other repos
and feature flags.)
ask_codebase("what does delete do?")
→ soft-deletes user, cascades to sessions
find_node("UserService.delete")
→ users/service.ts:88
relate({ kind: "callers" })
→ AdminController, CleanupJob, GdprHandler
(api-worker) +4 across 2 repos
relate({ kind: "blast_radius" }) → 7 sites
locate({ mode: "config" })
→ users.delete.soft: ON staging, OFF prod
list_tests_for("UserService.delete")
→ 5/7 covered; 2 callers untested
Blocking: prod flag is OFF, so the 2
untested callers still hard-delete. Add
tests and enable the flag before merge.
Benchmark A
tRPC, open-source TypeScript framework
Median correctness
baseline 0.79
1.00+27%
Task wins
10 tasks · bugs, features, refactors
9 / 10
Token usage
vs baseline
+6%
Benchmark B
cal.com, open-source TypeScript application (2M+ lines)
Median correctness
baseline 0.68
1.00+47%
Task wins
10 tasks · 3 ties · 1 baseline
6 / 10
Token usage
vs baseline
−15%
How we measured this
10 tasks per repository, drawn at random from real merged pull requests: bugs, refactors, and features engineers actually shipped. Each task runs twice from the exact commit before the human fix landed, in an isolated git worktree. The baseline has standard shell and grep. Symvanta has only MCP tools, no grep, no bash. An independent judge compares each diff against the real merged solution and scores functional equivalence: 0, 0.5, or 1. A win means Symvanta scored higher than the baseline on that task.
Baseline: grep + raw file reads, no Symvanta. Both benchmarks run on publicly available open-source repositories: tRPC and cal.com, the same repos the live demo above queries.
From code review to onboarding.
Same graph.
Every workflow your team already does, answered faster, with full graph context behind every response.
Onboarding
Ask the codebase in plain language
New hires get a synthesized answer with citations instead of chasing grep trails through twenty files.
Refactoring
Every call site, before you change a signature
Resolve all callers in one query, so a rename or a new return type lands without surprise breakage.
Multi-day RFC
Pick up the branch, not stale main
Pin a session to your feature branch, and even uncommitted edits, so the agent answers from where you actually are.
Branch-aware. Graph-backed.
Zero configuration.
Symvanta runs entirely in the background. You push code, and Symvanta keeps the knowledge graph current for your default branch and the feature branches you are working on.
01
Push to a tracked branch
Symvanta receives a GitHub webhook and always indexes your default branch. Open a pull request and that feature or RFC branch is tracked and indexed too, so agents can pin to the branch they are working on. Fork PRs and untracked branches stay out of the graph.
GitHub webhook02
Code parsing + graph update
Source files across 11 supported languages are parsed into logical nodes. The graph is updated: nodes upserted, edges re-derived. Relationships like calls, mutates, and exposes are inferred with confidence scores.
Language-aware parsingCode graph03
Inference on demand
Summaries are generated only when requested and cached for fast follow-up reads. The graph stays authoritative, and cached summaries refresh as new merges update the underlying nodes.
Generate-on-readSummary cache04
Your team's agents query via MCP
Cursor, Claude Code, Codex, and any MCP-compatible agent can query repository-scoped graph context directly. Resolve nodes, inspect callers or blast radius, and search indexed code, all through the same graph-backed source of truth.
MCP serverYour AI agents.
Your codebase. Connected.
Connect Symvanta to Cursor, Claude, or any MCP-compatible agent in minutes. No plugins, no file watchers, just structured knowledge served on demand across all supported languages.
find_node(selectors)
Resolve a symbol and return its full metadata in one call. Replaces the resolve + inspect sequence.
ask_codebase(query)
Ask a natural-language question about a repository and get a synthesized answer with citations.
locate(query)
Search across all repositories in a project and return ranked candidates from every repo.
relate(kind, selectors)
Return the graph-derived impact surface for a change so agents can reason about downstream breakage.
ref(op, repository, branch)
Pin a session to a feature or RFC branch so every query reflects that branch, not just the default. ref(op: clear) reverts.
// .cursor/mcp.json
{
"mcpServers": {
"symvanta": {
"url": "https://mcp.symvanta.com/mcp"
}
}
}
// That's it. Your agent now has
// structured access to your indexed codebase.
Lean context by query type
Exact symbol lookupsmallest retrieval slice
Callers / dependenciestargeted graph context
Architecture questionsbroadest graph read
Cross-repo
callers and blast radius traced across every repo in your project
11 languages
TypeScript, Python, Go, Rust, and 7 more, parsed into one graph
Minutes
to index a 100k-line repo, then incremental on every push
Source-free
the graph is built, then your code is discarded unless you opt in
Symvanta is built with Symvanta: our own repositories index to 43k symbols and 1.1M+ relationships, re-indexed on every push and queried through the same MCP endpoint you get.
Start free.
Scale with Enterprise.
Starter and Pro include a 7-day free trial, no credit card required.
Starter
For solo developers and small projects
$15
per month, 1 seat, billed monthly
- ✓Up to 5 repositories
- ✓Up to 2 projects
- ✓Single seat
- ✓Cross-repo intelligence
- ✓Every code-intelligence tool
- ✓2 tracked feature branches
- ✓7-day free trial, no credit card required
- ✓Cancel anytime, no annual contract
Need more? Add repositories ($3) or projects ($5) per month.
Start free trial →Pro
For teams putting AI agents to work across their codebase
$25
per user / month, billed monthly
- ✓Unlimited repositories
- ✓Unlimited AI answers
- ✓Cross-repo intelligence
- ✓Every code-intelligence tool
- ✓5 tracked feature branches per seat
- ✓Single sign-on (SSO / SAML)
- ✓Priority email support
- ✓7-day free trial, no credit card required
- ✓Cancel anytime, no annual contract
Enterprise
For engineering organizations deploying AI agents at scale
Custom
Contact sales, 15-seat minimum
- ✓Everything in Pro
- ✓Unlimited tracked branches
- ✓On-prem and self-hosting
- ✓SCIM directory sync
- ✓Enforced two-factor authentication
- ✓Audit logs
- ✓Bring your own LLM
- ✓Custom invoicing and PO
- ✓Dedicated SLA
Supported languages
TypeScript, JavaScript, Python, Java, Kotlin, C#, Go, Rust, Swift, PHP, Ruby
Questions about Enterprise?
info@symvanta.com
info@symvanta.com
Common questions.
Straight answers.
Does it work with private GitHub repos?
Yes. Symvanta uses GitHub webhooks and encrypted per-tenant credentials. Private repos work identically to public ones.
What data do you store?
We store a graph of code symbols and relationships (nodes, edges, file hashes) plus vector embeddings for semantic search, isolated per tenant and encrypted in transit. By default your source is never kept: it is parsed in memory to build the graph and the working copy is then discarded. Stored source is an optional, paid add-on that stays off unless you explicitly turn it on; when enabled it powers instant file reads and in-repo search for your CI and headless agents, and you can turn it off again at any time. Uncommitted edits made queryable with index_working_tree are indexed into a short-lived revision (reclaimed after a few hours) scoped to your tenant. Our Security page at symvanta.com/security walks through the full parse, graph, and discard pipeline.
How long does indexing take?
A typical 100k-line repo indexes in a few minutes. Incremental re-indexing on subsequent pushes is faster: we skip unchanged files using content hashing.
Does it work across multiple repositories?
Yes. Repositories in a project share one graph: imports are resolved past the package name back to the source repository, and HTTP calls between services become cross-repo edges. Ask for the callers or blast radius of a shared symbol and consumers in other repositories are part of the answer. Cross-repo intelligence is included on every plan.
Can my agent see my feature branch or unmerged work?
Yes. Open a same-repo pull request and Symvanta auto-tracks and indexes that branch (you can also add a branch from the dashboard). Your agent pins a session to it with ref(op: "use"), so every query answers from the branch instead of the default. Uncommitted working-tree edits can be made queryable too via index_working_tree. The number of tracked branches depends on your plan.
Why not just use a free or local code-graph tool, or my editor's built-in indexing?
A local index lives on one machine and covers one clone in one editor, so every developer rebuilds and maintains their own copy and it only knows the repository currently open. Symvanta is one graph shared by the whole team, kept current automatically: you push, a webhook re-indexes the changed files, and nobody rebuilds anything by hand. It resolves relationships across repositories, so the callers or blast radius of a shared symbol include consumers in your other services, not only the repo in front of you. Because it answers over an authenticated endpoint, headless CI agents and code-review bots read the same graph an IDE session does. And it can pin a session to a specific branch and index uncommitted working-tree edits, so answers stay accurate when you switch branches or work before committing. For one developer on one repository a built-in index is fine; the value here is a graph that is shared, cross-repo, always current, and reachable from outside any single editor.
Does it work with my existing Cursor or Claude Code setup?
Yes. Add the Symvanta URL to your .cursor/mcp.json or Claude Code MCP config. It runs alongside any other MCP servers you already use.
Which languages are supported?
TypeScript, JavaScript, Python, Java, Kotlin, C#, Go, Rust, Swift, PHP, and Ruby.
Can I cancel anytime?
Yes. Pro is month-to-month: cancel anytime with no annual contract. Enterprise runs on a custom term. Contact us at info@symvanta.com to discuss your needs.
Do you train AI models on my code?
No. We never train, fine-tune, or improve an AI model on your code, and we never share it across tenants. Your source is parsed into a graph in memory and then discarded unless you turn on source storage, so every answer comes from the graph, not a model that learned your code.
Which AI models process my code?
Open models on GPU infrastructure Symvanta operates in the EU: Gemma generates symbol summaries and graph answers, and Jina code embeddings powers semantic search. Your code is never used to train or fine-tune any model.
Who is behind Symvanta?
Symvanta LLC, a US company, built and run by its founder, Ugur Demirag. The story is on the landing page under Meet the founder, the work ships in public on X (x.com/Symvanta) and GitHub (github.com/Symvanta), and email to info@symvanta.com reaches the founder directly.
Who is behind this.
You are about to connect private code. You should know exactly who holds the other end.
Ugur Demirag
Founder, Symvanta
I started Symvanta after watching AI agents guess their way through real codebases: grep a name, pick the wrong caller, break prod with full confidence. The missing layer is a real code graph (symbols, callers, blast radius, cross-repo links) served to the agent over MCP. So I built it.
Symvanta runs on its own repositories every day, and every number on this page comes from an eval that can be rerun. When something fails at scale, it gets documented next to the wins.
Before Symvanta: 18 years of backend engineering, from pushing a million-plus real-time hits through three servers to leading a search infrastructure team, most of it deep inside other people's large codebases.
Ready to stop your agents from guessing?
Connect a repo and see it on your own code in minutes.