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 gives it a live graph of your code: who calls what, and what breaks if it changes.

No re-explaining. No hallucinated imports. No broken refactors.

+47%
more correct answers on a 2M-line repo
15% fewer
tokens for the same answers
<5 min
to index a 100k-line repo, zero setup
Start free trial →Book a demo

7-day trial, no credit card. See it on your own code in minutes.

CursorClaude CodeCodex+ any MCP client
Agent fixes a bug
User prompt
“Fix the auth timeout bug users are reporting.”
// 1. Locate the flow
ask_codebase({ query: "Where is session timeout handled?" })
// -> SessionStore.refresh at auth/session.ts:88 uses stale TTL
 
// 2. Check what the fix affects before touching code
relate({ kind: "blast_radius", selectors: [{ nodeId: "auth/session.ts:SessionStore:refresh" }] })
// -> callers: [authMiddleware, tokenRefresher]
 
// 3. Patch the root cause with full context
edit auth/session.ts (2 files, 6 lines)
Agent responds
Root cause: stale TTL in SessionStore.refresh. Patched 2 files, no downstream callers broken.
User prompt
“Add an endpoint to export a user’s data as JSON.”
// 1. Match the existing route + controller pattern
find_http_route({ method: "GET", path: "/users/:id" })
// -> GET /users/:id at routes/api.php:24 via UserController.show
 
// 2. Inspect the model so the response shape is correct
relate({ kind: "dependencies", selectors: [{ symbol: "User" }] })
// -> fields: [id, email, settings], relations: [sessions, exports]
 
// 3. Write the endpoint in the codebase’s own conventions
edit routes/api.php + UserController.php (2 files, 28 lines)
Agent responds
Shipped GET /users/:id/export. Matches existing auth guard, pagination, and JSON envelope conventions.
User prompt
“Review PR #412. It changes UserService.delete.”
// 1. What downstream code depends on this?
relate({ kind: "blast_radius", selectors: [{ nodeId: "users/service.ts:UserService:delete" }] })
// -> callers: [AdminController, CleanupJob, GdprHandler]
 
// 2. Any feature flag gating the new path?
locate({ mode: "config", query: "users.delete.soft" })
// -> enabled in staging, disabled in production
 
// 3. Cross-check coverage against every caller
relate({ kind: "callers", selectors: [{ symbol: "AdminController.destroy" }] })
// -> AdminController untested under the new flag path
Agent responds
Blocking review: AdminController.destroy lacks coverage under users.delete.soft. Two approve-blockers flagged.
User prompt
“Rename getUserById to findUserByIdentifier across the repo.”
// 1. Find every call site in one call
relate({ kind: "callers", selectors: [{ symbol: "getUserById" }] })
// -> 14 call sites across 9 files
 
// 2. Resolve each caller to verify the call style
find_node({ selectors: callers })
// -> all callers use named imports, rename is positionally safe
 
// 3. Apply coordinated edits in one pass
edit 10 files, 14 call sites
Agent responds
Renamed across 10 files and 14 call sites. No call depended on the old positional signature, no breakage.
User prompt
“Continue the payments RFC on the billing-v2 branch.”
// 1. Pin this session to the RFC branch
ref({ op: "use", repository: "billing", branch: "billing-v2" })
// -> reads resolve billing-v2, not the default branch
 
// 2. Queries reflect the branch, not stale main
find_node({ selectors: [{ symbol: "InvoiceService" }] })
// -> InvoiceService.charge with the new RFC signature
 
// 3. Even uncommitted edits are queryable
index_working_tree({ changedFiles: […] })
Agent responds
Picked up billing-v2 with full context: the new InvoiceService signature, its callers, and my uncommitted edits. No re-explaining across days.
Rotate through common MCP read patterns

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

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
relate · blast_radius · handleCancelBookinganswered in 190ms
wide blast radius: 10 files across 4 packages
CalendarSyncService.cancelBooking()other packagepackages/features/calendar-subscription/lib/sync
api/cancel/route.tsapps/web/app/api/cancel
reportBooking.handler.tstrpc layerpackages/trpc/server/routers/viewer/bookings
+ 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.
ask anything about your own code…
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.

without symvanta
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.)
with symvanta
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
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
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.

From code review to onboarding.
Same graph.

Every workflow your team already does, answered faster, with full graph context behind every response.

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.

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 webhook
02
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 graph
03
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 cache
04
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 server

Your 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.
mcp config · cursor
// .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
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
Cross-repo
callers and blast radius traced across every repo in your project

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
Start free trial →
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
Contact sales →
Supported languages
TypeScript, JavaScript, Python, Java, Kotlin, C#, Go, Rust, Swift, PHP, Ruby
Questions about Enterprise?
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.
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.
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.

Ready to stop your agents from guessing?

Connect a repo and see it on your own code in minutes.

Start free trial →Book a demo