LLMGRAPH

Honest answers for coding agents.

Your agent asks before it edits. LLMGRAPH answers what it can prove, and says what it can’t.

Request an invite Read the docs

Your agent asks. Pick a question, or press 1–5.

who_calls?Who uses this?

Your agent is fast. It's also guessing.

Coding agents find their way around your code by searching text and reading files. On a real project that quietly costs you: wrong edits, a crowded context, a drained quota, and late nights.

One short answer. Every problem above, handled.

This is what your agent gets back when it asks who uses one function. Step through it. Each line tells your agent what is solid and what to double-check, and each one takes care of a problem from above.

llmgraph · who_calls Store.save (app/store.py:2): 1 certain, 1 in a set, 1 open  ✓ certain app/admin.py:3 reset w1  ◇ within_these, one of 3 app/service.py:4 persist -> {Store.save, PgStore.save, MemStore.save} (closed: repo only) [a] w2  ⚠ maybe_more app/service.py:8 persist_any (open: type unknown) w3  ⚠ plus 1 dynamic call nearby that could reach anything w4  – ruled out: 2 same-name calls (proven: other target) [a] w5  assumes [a]: all subclasses are in this repo (project setting)

llmgraph · check_my_changes: 1 file changed, 2 calls break  [delta] files changed since your last call: app/store.py: Store body differs; Store.save signature differs (parameters, types)  ⚠ breaks app/admin.py:3 reset: misses "tx" (certain) w1  ⚠ breaks if it runs Store.save app/service.py:4 persist: misses "tx" (within_these, one of 3, closed: repo only) [a] w2  ⚠ may break app/service.py:8 persist_any (open: type unknown) w3  ⚠ plus 1 dynamic call nearby that could reach Store.save w4  assumes [a]: all subclasses are in this repo (project setting)

Every other tool hands your agent a map that looks complete. We draw where it ends.

Complete-looking is the problem. A map with no edges sends your agent straight off a cliff. LLMGRAPH charts what it can prove, marks what it cannot see, and says why. Your agent knows where the solid ground stops.

1. Strong words need proof Called certain only when the type checker has settled that exact call.
2. Look-alikes ruled out Calls that only share the name are set aside, with the reason.
3. Blind spots counted Run-time calls, code outside the repo, unread files: counted, never hidden.
4. Assumptions said out loud A line that rests on one is tagged, and the answer states it.
5. Never rounded up Labels are never rounded up: built into every answer, and tested on every build.

• charted: proven, or one of a known list
• marked: it cannot see here, and says why
• what other tools do: leave this blank, and say nothing

Being sure is easy. Saying what you don't know is the product.

Same question about the small example below, two answers. Drag to see what is really in its code.

An answer built from text matches (illustrative) who calls Store.save?

app/admin.py:3 reset

app/service.py:4 persist

app/service.py:8 persist_any

app/service.py:6 PgStore().save(item)not a caller

app/cache.py:5 c.save()not a caller

app/plugins.py:14 getattr(handler, name)(item)missed

5 callers found. Safe to change. ✓

LLMGRAPH (the engine's real answer for this example) who_calls Store.save

✓ certain app/admin.py:3 reset

◇ within_these, one of 3 app/service.py:4 persist -> {Store.save, PgStore.save, MemStore.save} (closed: repo only) [a]

⚠ maybe_more app/service.py:8 persist_any (open: type unknown)

⚠ plus dynamic calls elsewhere that could reach anything

– ruled out: 2 same-name calls (proven: other target) [a]

assumes [a]: all subclasses are in this repo (project setting)

who_calls Store.save (app/store.py:2): 1 certain, 1 in a set, 1 open

The example code (5 small files, illustrative)

app/store.py

1 class Store:

2 def save(self, item): ...the function asked about

3 class PgStore(Store):

4 def save(self, item): ...

5 class MemStore(Store):

6 def save(self, item): ...

app/admin.py

1 from app.store import Store

2 def reset():

3 Store().save(None) text match · calls Store.save

app/service.py

1 from app.store import Store, PgStore

3 def persist(s: Store, item):

4 s.save(item) text match · one of the three save methods

5 def archive(item):

6 PgStore().save(item) text match · this is PgStore.save, another function

7 def persist_any(s, item):

8 s.save(item) text match · the type of s is unknown

app/cache.py

1 class Cache:

2 def save(self): ...

4 def flush(c: Cache):

5 c.save() text match · this is Cache.save, another function

app/plugins.py

12 def run(handler, name, item):

13 # the method name arrives at run time

14 getattr(handler, name)(item) no "save(" in the text · could call it at run time

what the answer sayswhat is really in the code

What other kinds of tools leave unsaid

Text search Finds every line with the name. Cannot tell a real call from a look-alike, and misses calls made through aliases.

Similarity search Finds code that looks related, ranked by resemblance. Cannot tell you it found them all.

Editor find-references Precise when the types are known. Quietly drops the calls it cannot resolve.

Other code-graph tools Present a graph as fact, or put a number on each guess.

LLMGRAPH Says what it proved, what it ruled out, and exactly what it cannot see.

Set up once. Then your agent just knows.

before you start Windows 10 or 11 (x64) Node.js 16 or later an agent that speaks MCP Python or TypeScript / JavaScript up to 50,000 lines per repo

terminal

01

Read the full setup guide Every step in detail, other agents, and what to do if something goes wrong.

Don't just install it. Watch your agent use it.

Agents don't always reach for a new tool on their own. One line teaches yours the habit, and two small checks show you it stuck. You can see it working, not just installed.

1 Tell it CLAUDE.md

# notes for the agent

One line in your agent's instructions file. Our suggestion; word it your way.

2 Watch it ask your agent

Every answer starts with llmgraph ·. LLMGRAPH adds it to every answer itself, so look for it where your agent shows what it asked: there it is, asked before the edit.

3 Check the count terminal

One command prints today's count of questions asked. Counts only: never your code, names or questions.

Agents that speak MCP

Claude Code set up and checked first Antigravity set up and checked Cursor setup guide Codex setup guide Gemini CLI setup guide OpenCode setup guide Windsurf setup guide

Using another agent? If it speaks MCP, it can use LLMGRAPH. See the setup guide.

Closed betaInvite onlyLimited seats

Get in at the beta price. Keep it for life.

Join during the beta and your price stays the same for as long as your subscription stays active. When the beta ends, the price goes up and the invites stop.

Beta seat · yearly

$5/ month

billed annually Request an invite

Beta seat · monthly

$7/ month

billed monthly Request an invite

Both include

• All five questions your agent can ask
• Up to 3 repositories, up to 50,000 lines each
• 2 devices
• Your code never leaves your computer: the only server LLMGRAPH contacts is our licence service. We checked it on the released program.
• Python and TypeScript / JavaScript

7 days free. No card required. The trial starts when you approve your first device.

Locked for life. Your beta price stays as long as your subscription stays active. Cancelling ends it.

Cancel any time. You keep access to the end of the period you paid for.

Tax included. Payments are handled by Dodo Payments, the seller of record.

1. Finds every caller in your code.Not quite. Code that picks its call while it runs can hide one.
2. Never wrong.Nothing that reads code is.
3. Tells your agent which callers are certain, and which ones it cannot see.

your agent

is llmgraph worth it?

llmgraph · what_is_unknown: you

certainit shows the callers it can prove, with file and line

cannot_seeyour repository, until you add it

Illustrative. The labels are the product's own.

That's the pitch.

Want proof first? See real answers on open-source repos, or read the questions and answers.