Understand unfamiliar code with evidence.

Read a Wiki of how a repository works, follow its call paths, and inspect the source behind each explanation.

No account or API key needed for the example.

A map of the psf/requests Wiki: pages as coloured nodes, joined by the references recorded between its areas.

Ask one question. Land on the exact lines.

Each step is a call the index recorded. Click one to read the source it points at. No account or API key needed.

Explore how Requests handles redirects →

Results, measured on public tasks.

Two evaluations, each with its tasks, its method and what it does not show written up in full.

Thread context cuts an agent's input tokens by a fifth to a half

Change in input tokens when the agent is handed the codenib threads context, against reading the thread itself with gh. Zero is no change.

  1. Codex gpt-6.1-sol · 76 pull requests

    −21%
  2. Codex gpt-6.1-sol · 47 issues

    −25%
  3. Claude Code Claude Opus 5.5 · 76 pull requests

    −45%

Each dot is the change over all the tasks, and each line its 95% interval. The agents found the files to change about as often either way: 0.75 against 0.74 and 0.85 against 0.82 with Codex, 0.80 against 0.83 with Claude Code. Scope and method →

#1 in line recall and Pass@1 on ContextBench's Agent systems leaderboard

Tasks resolved on the first attempt, by the benchmark each task comes from. Over all 500 tasks: 77.60% Pass@1 and 77.90% line recall.

  1. SWE-Bench-Verified 152 of 174

    87.4%
  2. SWE-PolyBench 92 of 116

    79.3%
  3. Multi-SWE-Bench 110 of 156

    70.5%
  4. SWE-Bench-Pro 34 of 54

    63.0%

Official leaderboard as of October 23, 2026 (UTC). This is our research agent, not the Wiki or the code graph: it searches with glob, grep and reads. Read how it works →

Now explore your own repository.

Paste a public GitHub repository. CodeNib draws its folders as a map, plans the chapters on it, and fills each one in as its sources check out. Read chapters as they finish, then return to your saved link.

Ready Wikis open instantly. A new Wiki uses your OpenRouter account and credits, with a $0.25–$5 spending limit you choose before starting.

Hosted limits and spending details

20 MiB download, 40 MiB retained files and 4,000 files. Files over 4 MiB are skipped. A provider call already in progress can exceed your spending limit.

Check repository eligibility before connecting OpenRouter →

Want to keep exploring first? Browse ready Wikis → Publish yours on GitHub Pages with the CodeNib Wiki action.

Take that context to your coding agent.

Build a local index for Claude Code or Codex. Find definitions, follow callers and read the source in your own checkout.

One recorded Claude Code session on Requests. explore_context found rebuild_auth(); one dependency_subgraph call returned these callers, each with a file and line.

Full recorded transcript

$ codenib codegraph init . --agent claude

Languages: python

bm25 fresh (1.92s)

symbol_graph fresh (16.49s)

CodeGraph is ready for coding agents.

MCP server: codenib-requests-b447e805b6ad

Clients: claude

> Use CodeNib's explore_context once to find where Requests strips authentication when redirecting to another host. Then call dependency_subgraph once on that function with direction impact and depth 4 to trace which public Session method reaches it.

explore_context "strip authentication headers when redirecting to different host"

sessions.py:282–300 rebuild_auth()

sessions.py:127–157 should_strip_auth()

dependency_subgraph rebuild_auth() impact depth 4

hop 1 sessions.py:159 resolve_redirects()

hop 2 sessions.py:673 Session.send()

hop 3 sessions.py:500 Session.request()

hop 4 8 public entry points

rebuild_auth (src/requests/sessions.py:282) strips the Authorization header when should_strip_auth (sessions.py:127) detects a hostname change on redirect.

Session.get/post/… (:593+) → Session.request() (:500) → Session.send() (:673) → resolve_redirects() (:159) → rebuild_auth() (:282)

14.1 s · 3 turns · 2 tools · $0.078 list-price estimate · source unchanged

The recorded source is unchanged. Session details and pinned sources →
python -m pip install "codenib[graph,mcp]"
codenib codegraph init /path/to/your/repo

Needs Python 3.10+, Git, and Claude Code or Codex. Uncommitted edits are fine. CodeNib runs locally here with no model, API key or GPU of its own; your agent uses its own model.

Setup and language prerequisites · Ask your agent to start with explore_context.

Give your agent the whole thread, in one read.

In preview: codenib threads reads a GitHub issue or pull request once and writes one document for your agent. The ask, the reviews, the failing checks, the linked threads and the code they point at, with no model. When the agent comes back, it gets only what changed.

codenib threads context 8024

On 76 pull requests taken over after a review or a failed check, it cut input tokens by 21% with Codex and 45% with Claude Code, and the agents found the files to change about as often. See the results · Read how it works →

codenib threads boardpoll · nothing changed
  1. A

    #812Fix a short read in Reader.read()

    up to date

    Also in progress on Reader.read(): #815

  2. B

    #815Cache reads in Reader

    up to date

    Also in progress on Reader.read(): #812

  3. C

    #807Document the retry policy

    up to date

Three agents, each on its own pull request, share one store. Each is sent only the records it has not read, and two that touch the same function are told about each other.

A sketch with made-up pull requests. Each mark is one stored record; blue is one its agent has not been sent yet. See real output.

14 languages, 12 with a code graph.

See what CodeNib can do with yours, from a graph that updates as files change to plain code search.

  • Pythonlive graph
  • Golive graph
  • Rustlive graph
  • C/C++live graph
  • JavaScriptlive graph
  • TypeScriptlive graph
  • C#graph
  • Javagraph
  • Rubygraph
  • PHPgraph
  • Kotlingraph
  • Scalagraph
  • live graph updates as files change
  • graph takes a fresh index to pick up changes
  • search has no definitions or callers

Registered capabilities, not the tools on your machine; codenib toolchain status shows those. Open the language matrix →

Reproduce the methods
LocAgent, Agentless, CoSIL, OrcaLoca, RepoNavigator
Explore agent integrations →
Compare the fit
grep, Serena, CodeGraph, DeepWiki
Compare repository tools →
Experimental retrieval
71.4% code-block Recall@5 on 100 real issues, 12.8 points above the same grep candidates without reranking.
Method and limitations →

Questions

Does CodeNib need a model or an API key?

Not for the code graph, search, or thread context: they are built by code on your machine, and your agent uses its own model. A Wiki built locally is written from the index without a model unless you ask for model-written pages. Reading a ready Wiki on the demo needs no account.

What does a Wiki of my own repository cost?

On your machine, nothing beyond the model you choose to point it at, and it can run with none. On the demo, a new Wiki of a public repository uses your OpenRouter account, with a spending limit of $0.25 to $5 that you set before it starts.

Is the Wiki written by a model? How do I check it?

The sentences of a model-written page are. The map, the call paths and the citations are not: they come from the code index, and no model chooses the arrows. Each sentence ends with the file and line range it comes from, so a claim can be checked against the source in one click.

Is the ContextBench result a result for the Wiki?

No. It belongs to our research agent, which searches with glob, grep and reads. It does not use the Wiki or the code graph. The ranking is the official Agent systems leaderboard as of October 23, 2026 (UTC).

Can't an agent already get a whole thread with one gh pr view --json call?

One call returns the comments, reviews, changed files and check states. It does not return review comments on lines of code, the log of a failed check, or the threads the pull request links to, and those are the further calls an agent makes. In our evaluation the agent reading with gh already got comments, reviews and line comments in one call, and the prepared context still used 21% to 45% fewer input tokens. We ran that comparison on a read-only copy of gh, not on --json itself.

Why not paste the whole thread into the prompt?

On a short issue that costs about the same. On pull requests it costs more, because checks and logs come with it: the prepared context used 32% fewer input tokens than pasting with Codex and 69% fewer with Claude Code. For Claude Code the 76 tasks cost $17.49 pasted, $11.34 reading with gh, and $8.37 prepared.

Does a prepared thread make the agent's answer worse?

With Codex, no: it found the files to change as often, 0.75 against 0.74. With Claude Code it found slightly fewer, 0.80 against 0.83, a gap too small to tell from chance on 76 tasks. If finding every file matters more to you than cost, let the agent read the thread itself. The evaluation checks which files the agent names, not whether it then writes a better fix.

Try it where you write code.