CoGraph

v1.2.0—Free on the VS Code Marketplace

AI already writes your code.We make sure you still understand it.

CoGraph shows which functions in your repository call which, as a graph next to your code in VS Code. It reads the source and never runs it. Same code, same graph.

Install for VS Code
code --install-extension thraenbe.cograph
The CoGraph extension in VS Code: a call graph of the extension's own analyzer scripts, grouped by file, with the layout controls and the chat panel beside it.
Fig. 1CoGraph for VS Code · CoGraph's own analyzers, read as a graph
Installs
667
VS Code Marketplace, Sep 2026
Languages
5
Python · TypeScript · JavaScript · Java · C++
Licence
MIT
Free and open source
Cyber Valley
Winner
Best Business Award · Cyber Valley AI Incubator
01 · The problem

More code reaches review than anyone has time to read.

Coding assistants changed how fast code gets written. They didn't change how fast a person can understand it — and understanding is still what review, onboarding and every architectural decision depend on.

01

A diff shows lines, not structure.

It tells you which lines changed. It doesn't tell you what calls them, or what they reach. That part you rebuild in your head, every review.

02

Nobody wrote all of it.

When much of a module came from an assistant, there is no author to ask how it fits together. The mental model has to be recovered from the code itself.

03

Hand-drawn maps go stale.

An architecture diagram is right the day it is drawn and drifts from then on. A stale map is worse than no map.

02 · How it works

Derived from the code. Not generated about it.

There is no model guessing at your architecture. CoGraph reads the syntax tree and records what is there — so the graph you see today is the graph you'll see tomorrow, until the code changes.

  1. 01 · Parse

    Each language's own parser reads your workspace: Python's ast, the TypeScript compiler API, java-parser, tree-sitter for C++. Each runs as a local process, and your code is never executed.

    app.pyFig. 2a
    1def checkout(cart):
    2 total = price(cart)
    3 bill = invoice(total)
    4 notify(bill)
    5
    6def price(cart):
    7 return cart.subtotal
    8
    9def invoice(total):
    10 return render(total)
    11
    12def render(total): ...
    13def notify(bill): ...
  2. 02 · Derive

    Every function definition becomes a node, identified by file, name and line. Every call the parser can resolve becomes an edge. The same code always yields the same graph.

    analyzer → stdoutFig. 2b
    {
      "nodes": [
        { "id": "app.py::checkout::1",
          "name": "checkout", "line": 1 },
        { "id": "app.py::invoice::9",
          "name": "invoice", "line": 9 },
        …
      ],
      "edges": [
        { "source": "app.py::checkout::1",
          "target": "app.py::invoice::9" },
        …
      ]
    }
  3. 03 · Read

    The graph opens beside your editor. Click a node to jump to its definition. Save a file and the graph is derived again.

    CoGraphFig. 2c
    pricerendernotifycheckoutinvoice
03 · The extension

Read your codebase like a metro map.

Free in VS Code today. Open a folder, run CoGraph: Visualize Project from the command palette, and move through the code by what calls what.

Open in the Marketplace
checkout.pypayments.pylog.pystripe (4)checkoutvalidate_cartapply_discountcharge_cardretry_paymentrefundlog_eventformat_amount
Fig. 3 · Grouped by file, one function selected

Every function a node. Every call an edge.

Zoom, pan and filter by name. Group by folder, file or class, and use the detail slider to fold low-connectivity nodes away until the structure is legible.

Click a node, land on the code.

Jump to any function's definition, or open its source in a popup you can drag, resize and keep open beside others.

See what your working tree touched.

Colour nodes by git status — modified, new, deleted, staged — to see where your uncommitted work sits in the structure and what it's wired to. It refreshes when the git index does.

Derived again on save.

Save a file and the graph is re-derived. In large repositories only the saved file is re-parsed.

Sized for real repositories.

Large-repo mode starts with an instant folder skeleton and parses folders as you open them. External libraries collapse into one node each.

Replay how it grew.

Timeline playback builds the graph in commit order, so you can watch an architecture take shape.

Optional · off by default

AI only if you ask for it.

An architecture chat and a workflow view can sit on top of the graph. Nothing runs until you enable them; then they use your own Claude Code or Codex CLI, with your own keys and a budget cap per request. The graph never depends on them.

graphIntelligence.enabled: falsemaxBudgetUsdmaxTurns
04 · Your code

It runs where your code is.

  • No account, no CoGraph server.

    Analysis runs in local processes on your machine. There is nothing to sign up for and nowhere for your code to be uploaded to.

  • Your code is never executed.

    The graph comes from static analysis. CoGraph parses your source files; it never imports, builds or runs your project.

  • With AI off — the default — nothing leaves.

    The optional AI features are the only part that talks to a model, through your own CLI and account, and only once you switch them on.

05 · Roadmap

One graph. Three places it belongs.

The editor is the first surface. Because the graph is derived the same way every time, it can also live in the repository and be compared across pull requests. That work is in design, and we are shaping it with design partners.

  1. Shipped

    In the editor

    CoGraph for VS Code. Read the graph where you write the code.

    v1.2.0 · Free · MIT
  2. In design

    In the repository

    The graph as a file committed next to the code — byte-stable output and a documented schema, versioned like everything else.

  3. In design

    In the pull request

    Regenerate the graph for each pull request and compare it with the base branch. The diff shows which functions and calls a change adds, removes or rewires.

main → feature/retry-paymentsFig. 4 · Concept
checkout+ retry_paymentcharge_cardgatewaylog_event
added removed unchanged
Interactive demo · not a product yet

CoGraph Review

A pull request page with the change read on the graph. It shows the direction; it is not something you can install.

06 · Design partners

Shape the team version with us.

We are looking for a few engineering teams to pilot what comes next. It's an invitation to shape something, not a pitch to buy something.

A good fit
  • 5–50 engineers
  • Python or TypeScript
  • Code on GitHub, work in VS Code
  • AI assistants in daily use
  • Review load you can feel
Message Magnus
How a pilot runs · free · one repository
  1. Before

    We reconstruct a baseline from your last 90 days of pull requests.

  2. Week 1

    Install on one repository.

  3. Weeks 2–3

    Use it in real review, with a direct line to both founders.

  4. Week 4

    We go through the results together — including what didn't work.

07 · Team

Two founders who needed this themselves.

CoGraph came out of a working engineer's own problem — Bela started it after a data-science internship at Bosch. We build it in Tübingen, in the open.

Portrait of Magnus Hornstein

Magnus Hornstein

Co-founder · Business & Strategy

Finishing an ML master's at the University of Tübingen. Pairs technical depth with a strategy-consulting background to steer product and go-to-market.

Portrait of Bela Thrän

Bela Thrän

Co-founder · Engineering & Product

Computer Science master's at the University of Tübingen. Originated CoGraph after a data-science internship at Bosch, and writes most of the extension.

Incubated atCyber Valley AI IncubatorWinner of the Best Business Award
Based inTübingen, GermanyFounders from the University of Tübingen
Built in the openMIT-licensed on GitHubIssues and pull requests welcome →
08 · Questions

The things engineers ask first.

Something missing? Open an issue on GitHub or message us — we answer both.

01Is CoGraph free?

Yes. The VS Code extension is free and MIT-licensed, and the source is on GitHub. A team version for repositories and pull requests is in design with design partners.

02Does my code leave my machine?

Not with the extension. Parsing happens in local processes and there is no CoGraph server. The one exception is the optional AI layer: it is off by default, and once you enable it, it runs through your own Claude Code or Codex CLI under your own account.

03Is there an LLM in the loop?

Not in the graph. Nodes and edges come from each language's parser, so the same code always produces the same graph. The optional AI features — an architecture chat and a workflow view — sit on top of it and are off by default.

04Which languages are supported?

Python, TypeScript, JavaScript, Java and C++. Coverage is strongest in Python and TypeScript. Calls that only resolve at runtime — dynamic dispatch, reflection, eval — are not in the graph, and macro-heavy C++ is covered partially.

05How large a repository can it handle?

Large-repo mode engages automatically: it shows an instant folder skeleton, parses folders lazily as you open them, and caches results between sessions. Repositories the size of NumPy or Django stay navigable.

06How is this different from an AI code reviewer?

An AI reviewer writes comments on a pull request. CoGraph writes nothing: it derives a model of the code that you read yourself, and it never comments, approves or blocks. The two sit side by side.

End of line

AI writes the code. CoGraph is how your team still understands it.

Install the extension, open a folder, and run CoGraph: Visualize Project.

Install for VS Code
code --install-extension thraenbe.cograph