Context Graph

One graph for humans and agents, not a pile of tabs

To ship a single feature with a coding agent, most teams touch seven tools. Each one owns a slice. The connections between slices live in your head. A context graph turns those connections into typed, persistent links that both you and your agent can traverse.

Today

The graph lives in your head

Shipping one feature with a coding agent usually touches seven tools: ticket, thread, plan, diagram, mockup, diff, session.

Each owns one slice. The connections between slices live in human heads. An agent cannot traverse what was never recorded.

A context graph turns those slices into nodes and typed edges that both humans and agents can walk in a single traversal.

Read the full essay: Integrate 80% of everything →

Fragmented stack: the human holds the graph and stitches context across separate tools for every agent prompt

What changes

Context integrated into one shared graph

Ask your agent to pick up where the last session left off. Across a fragmented stack, that is a chain of lookups through separate tools and separate data models, and the agent may still not know which prior session touched the work.

In an integrated workspace, every artifact is a node and every relationship is a typed edge. Tracker item to thread to plan to spec to session to diagram to diff to files. One traversal, not seven lookups.

Any agent can plug into it. Claude Code, Codex, OpenCode, or whatever lands next.

One integrated workspace: every artifact is a node, the agent traverses the graph in one call

Visual editors

Edit every node without leaving the graph

A graph of typed edges only works if you can edit what is on the other end without leaving the place you started.

Open the diagram from inside the tracker item. Pull up the mockup without leaving the spec. Click into the embedded diagram and the spec updates.

A markdown spec with an Excalidraw diagram embedded inline inside Nimbalyst
A markdown spec with an Excalidraw diagram embedded inline. Click into the diagram, change it, and the spec reflects the change.

Agent and human edit the same artifact. Red and green diffs are visible to both. The visual surface and the agent's working surface are the same surface.

Mockup editor with red and green AI diff
Mockup editor with red and green AI diff

The 80%

Build the 80% that matters, integrate into one graph

Deeply integrated agent context will not exist as long as work is scattered across eight SaaS apps.

Nimbalyst builds the 80% of those products that matters and ties them into one graph.

  • Tracker for tickets, bugs, decisions, and ideas
  • Markdown editor with WYSIWYG and red/green diffs
  • Diagrams as first-class files
  • Mockups that render
  • Code editor
  • Sessions that persist

Message threads are next. Conversation around a piece of work is part of the work.

FAQ

Questions about the context graph

What is a context graph?
A context graph is a network of typed, persistent links between the artifacts your work touches. Tracker items, plans, specs, diagrams, mockups, sessions, diffs, files, and commits become nodes. The relationships between them become edges. Both humans and agents can traverse the graph instead of stitching the connections together from memory or from open browser tabs.
How is a context graph different from a knowledge graph?
A knowledge graph stores facts and relationships about entities in general. A context graph is project-specific: it captures the working state of a real codebase and team, with edges that connect tracker items to sessions, sessions to diffs, diffs to files, and decisions to the work that forced them. It is built for what your coding agent needs to know to make the next change, not for general retrieval.
Why does my agent need a context graph?
Without one, your agent only sees what fits in the current prompt. The ticket does not know which session touched it. The plan does not know which diagram shaped it. The session does not know which thread changed the requirement. A human has to reconstruct that context from open tabs every time. With a context graph, one prompt can pull in the related plan, prior session, design diagram, and affected files in a single traversal.
Can I bolt a context graph onto Jira, Notion, Figma, and Claude Code?
Partially. You can build link tables and integrations, but the underlying data lives in eight different SaaS products with eight different auth models and eight different data models. The cheapest path to a usable graph is to integrate the 80% of those products that actually matter into one workspace, which is the approach Nimbalyst takes.
Does the context graph work with Claude Code and Codex?
Yes. Nimbalyst runs Claude Code and Codex as first-class agents and exposes the context graph to whichever one a session is using. The agent layer is pluggable, so the same graph can be traversed by OpenCode or whatever model lands next.
Is the context graph open and inspectable?
Yes. The Nimbalyst desktop app is MIT licensed and you can read the tracker schema, the session model, and the graph model in the open repository on GitHub. Your data stays on your local file system in open formats.

Nimbalyst: the open-source visual workspace for building with Codex, Claude Code, and more

Download
Also available for: macOS Apple Silicon macOS Intel Windows Linux