# Real answers from real runs

> What LLMGRAPH actually says to a coding agent, copied from real runs on open-source repos, including where it can't see and where it loses.

Many call graphs guess when they can't resolve a call, and hand the guess to the agent as fact. LLMGRAPH is the truth layer between your agent and your repo: it never presents a guess as proven, labels every answer line, and names what it can't see.

You don't need an account to judge that. Below are real answers from real runs on open-source projects. The stop check's text is exactly as printed; in the other blocks we trimmed lines where marked.

## 1. It holds the agent when an edit breaks callers

An agent in Claude Code was asked to change `super_len(o)` to `super_len(o, strict)` in requests v2.32.3 and touch no other file. When it tried to finish, the stop check held it:

```text
LLMGRAPH: 8 calls break because of your edits:
src/requests/models.py:526 PreparedRequest.prepare_body: misses "strict"
src/requests/models.py:575 PreparedRequest.prepare_content_length: misses "strict"
tests/test_utils.py:62 TestSuperLen.test_io_streams: misses "strict"
tests/test_utils.py:63 TestSuperLen.test_io_streams: misses "strict"
tests/test_utils.py:69 TestSuperLen.test_super_len_correctly_calculates_len_of_partially_read_file: misses "strict"
tests/test_utils.py:82 TestSuperLen.test_super_len_handles_files_raising_weird_errors_in_tell: misses "strict"
tests/test_utils.py:95 TestSuperLen.test_super_len_tell_ioerror: misses "strict"
tests/test_utils.py:98 TestSuperLen.test_string: misses "strict"
Fix them, or tell the user why each is fine.
```

The agent listed the breaks and offered two fixes instead of finishing. In all, 16 calls broke; the other 8 were still being confirmed. Since version 0.4.5 the first line also says how many more aren't confirmed yet.

Raw: [stop-check-requests-2026-10-26.txt](https://beta.llmgraph.in/assets/captures/stop-check-requests-2026-10-26.txt) · LLMGRAPH 0.4.4, plugin 0.3.0, 26 October 2026

## 2. Two functions, one name: look-alikes ruled out

zod ships two copies of `addIssueToContext` (`src/` and `deno/lib/`). A text search returns 143 lines from both, mixed together. LLMGRAPH separates them:

```text
llmgraph · who_calls addIssueToContext (src/helpers/parseUtil.ts:72): 71 in a set
  ⚠ type checker starting: answers use our own reading for now; 71 calls unchecked
  ◇ within_these 71 calls -> one of 1 (closed: repo only) [c] w1
  ⚠ plus 7 dynamic calls nearby that could reach anything w2
  – ruled out: 71 same-name calls (proven: other target) [c] w3
  assumes [c]: our own reading, not confirmed by the checker
(lines trimmed)
```

Note the second line: the type checker hadn't confirmed yet, and the answer says so.

Raw: `https://github.com/brainfoods-studio/llmgraph-agent-plugin/blob/main/benchmarks/blind-test/answers/zod_who_calls_addIssueToContext.txt` · zod v3.23.8

## 3. It names what it can't see

Asked what it can't see in requests, LLMGRAPH counts its blind spots by kind and by file instead of hiding them:

```text
llmgraph · what_is_unknown (whole repo): 617 blind spots
  ⚠ dynamic call 174: tests/test_requests.py (161), tests/test_utils.py (6), +6 files w11
  ⚠ type unknown 443: tests/test_requests.py (286), src/requests/cookies.py (21), +17 files w12
```

And when it can prove callers, it says how far the proof reaches:

```text
llmgraph · what_breaks_if_changed super_len (depth 3): 22 places depend on it
  ✓ certain src/requests/models.py:526 PreparedRequest.prepare_body w3
  ✓ certain src/requests/models.py:575 PreparedRequest.prepare_content_length w4
  +12 more certain in 1 files w5
  ⚠ plus 9 dynamic calls nearby that could reach anything w6
  depth 2, each as strong as its weakest step:
  ◇ +2 more places at depth 2, as weak as within_these [a][c] w7
  depth 3, each as strong as its weakest step:
  ◇ +6 more places at depth 3, as weak as within_these [a][c] w8
  ⚠ 7 more deeper calls we can't see: not followed w9
  ⚠ 2 places beyond depth 3 not followed w10
  [a] is not confirmed for this repo: ask the user whether every subclass lives in this repo, then repeat with family yes, no or unsure
  assumes [a]: all subclasses are in this repo (project setting)
  assumes [c]: our own reading, not confirmed by the checker
(lines trimmed)
```

Raw: `https://github.com/brainfoods-studio/llmgraph-agent-plugin/blob/main/benchmarks/privacy/run2-answers.txt` · requests v2.32.3, the released npm 0.4.3

## 4. Where it loses: use ripgrep for unique names

On names that appear only once in a repo, a plain text search finds the same callers for fewer tokens. From our own benchmark on requests:

| Symbol | True callers | ripgrep: found, tokens | LLMGRAPH: found, tokens (with expansions) |
|---|---|---|---|
| `rebuild_proxies` | 3 | 3, 76 | 3, 310 |
| `get_netrc_auth` | 5 | 5, 115 | 5, 297 |

Use ripgrep there. LLMGRAPH earns its place when names collide, before you change something others depend on, and after an edit.

Raw: `https://github.com/brainfoods-studio/llmgraph-agent-plugin/blob/main/benchmarks/noisy-names/data/score_tables.md` · LLMGRAPH 0.4.1

## 5. Blind test: 50 questions, three repos

A tester with no access to the engine's internals asked 50 graded questions on requests, rich and zod. **No confident answer was wrong**: no line labelled certain, exactly_these or within_these was wrong. The same report lists where answers were misleading or unclear, and what we fixed.

Full report and raw answers: `https://github.com/brainfoods-studio/llmgraph-agent-plugin/tree/main/benchmarks/blind-test` · all results: `https://github.com/brainfoods-studio/llmgraph-agent-plugin/blob/main/BENCHMARKS.md`

---

Want to see it on your own code? [Request an invite](https://beta.llmgraph.in/?ref=proof): invites go out within minutes; 7-day trial, no card. Windows x64; Python and TypeScript/JavaScript.