Connect the line to the reason.
Move from company and product goals to a customer requirement, interface and implementation. Follow a proposed change back out to the people, promises and other systems it could affect.
CodeGraph / Connected context for people and AI
The whole picture.
The right context.
We’re building CodeGraph to connect company vision, customer needs and software, down to a line of code. Give people and AI the context to make informed decisions, with less repeated discovery and fewer tokens spent reconstructing what the organization already knows.
Our vision: shared understanding, focused context and independent action within clear authority.
Zoom in to act. Zoom out to understand.
Company vision → product purposeReliable field operations
Help inspectors finish the job wherever they work.
↕ personas, conversations and requirements
Customer need → interface“Saved on this device”
Survive a restart. Keep restricted attachments local.
↕ implementation and validation
Across repositoriesCapture → queue → sync
Down to the sourceRevision → function → line
Connected research, decisions and checks. A permitted view for each participant.
01 / Why CodeGraph
Give every decision
the context it needs.
CodeGraph began with a practical problem: AI repeatedly searching code and rebuilding context, spending tokens and still missing important connections. The answer we’re pursuing is a structured, connected understanding of the work, from the company’s purpose to the detail needed for the next decision.
Token efficiencyMore understanding
More understanding
per token.
Give AI focused context with the code, dependencies, purpose and critical constraints the task needs. Follow relationships, expand into exact sources and retain useful understanding across tasks. Finding existing capabilities before building them again is one way to reduce repeated work. Judge efficiency by total tokens per correctly completed task.
Focus the contextFollow the connectionsKeep the understanding
A connected systemOne focused task
RequirementConversationsResearchOther reposThis taskSave handlerDesignsRestart checkDecisions
Relevant context, ready to expand.
Purpose + exact source + critical constraints
Conceptual view · Connections stay available beyond the current focus.
Make informed decisions independently.
Give each person or agent relevant context, explicit authority and checks appropriate to the decision. Bring interacting proposals together for review, while owners retain control of acceptance.
The intended advantage is the combination: context at the right depth, connections across code and organizational knowledge, and governed participation in the same model.
How this fits with existing tools
Sourcegraph documents cross-repository code navigation, GitHub Copilot supports project instructions, and Backstage connects software with ownership and metadata. Those are useful foundations. The comparison that matters for CodeGraph is the effort to carry one change through understanding, implementation, review and reuse, including the work of keeping its model current.
02 / Zoom in. Zoom out.
From the customer’s need
to the line that serves it.
A storage decision shapes an interface promise. That promise serves a user requirement, a product and a company purpose. Explore how CodeGraph’s model is designed to keep those layers connected while changing the detail in view.
The person behind the requirementFinish the inspection.
Even without a connection.
Even without a connection.
Field operations↓Offline capture↓Survives a restart
Purpose → requirementIllustrative scenario
Reliable field operations → inspection product → offline capture
Why does saving offline matter?
A product owner needs to decide what “saved” promises to a field inspector.
- Customer context
- An inspector works beyond network coverage and may restart the app before returning.
- Requirement
- A confirmed inspection must survive a restart. Restricted attachments must remain on the device.
- Decision source
- Connect the customer conversation, approved requirement and the research behind the local-storage choice.
The check at this level
Does the acceptance criterion describe what the customer needs, including failure and recovery?
↕ Zoom in to the screen state and implementation that must honor this promise.
Illustrative navigation through one connected model. Source locations and workflow details are examples.
03 / What makes the model useful
Represent the knowledge
that gives code its meaning.
A repository contains part of the story. CodeGraph’s design also represents personas, requirements, interfaces, conversations, research, IP references, decisions and evidence. These become identifiable, connected information that both people and AI tools can navigate.
Start focused. Keep a path to the detail.
Retrieve by task, purpose and structure. Include critical constraints immediately, then expand into exact code, source passages and history. Human views and AI tools draw on the same relationships. Each result identifies its revision, provenance and coverage, so missing or unavailable context stays visible.
Find the behavior. Follow the consequences.
Trace the callers that reach a function and the calls and dependencies it reaches. CodeGraph’s technical foundations include function-level caller indexing, change-driven test-impact ranking and code-to-deployment traversal. The direction is to connect those paths across repositories with requirements, interfaces and operating constraints, so contributors can scope a change and identify what needs checking.
Fan-in · who calls itFan-out · what it calls
Inspection formBatch import
Proposed change
saveInspection()Local storageUpload queue
Know why two things are connected.
A design proposes an approach. A function implements part of it. A test checks a particular behavior. Each connection carries its source, owner and relevant version. Observed, inferred and unresolved relationships stay distinct, so a plausible link does not become an acceptance decision.
Carry understanding into the next project.
“Offline capture” is a capability; its mobile and desktop versions are implementations. Keep the purpose, requirements and reasoning identifiable through rewrites. Connect consumers and adaptations so a useful improvement can reach the next project as a reviewable proposal.
See which conclusions a change puts back in question.
Bind checks and decisions to the code, assumptions and operating conditions they concern. When that support changes, identify what needs another look and retain the history behind the previous decision.
Keep the model accountable to the work.
Derive connections from code analysis and execution, and capture human rationale when decisions are made. Compare predicted impact with actual checks. Keep the source revision and freshness visible, and use discrepancies to correct the model.
04 / Connected participation
More contributors.
Precisely scoped
participation.
People, teams, partners and AI agents need different views and different authority. CodeGraph’s permission design uses the relationships in its model to define scopes that can cross files and repositories or select particular sections of code.
The direction combines 8Braid’s confidence-based access control, CBAC, with explicit participant identity, delegation and resource boundaries. Confidence operates within granted authority.
Explore the protection foundation →Connect access to the work.
Combine capability, requirement, project, owner, sensitivity, task, environment and contributor role. A designer could discuss an interface while a specialist proposes a change to its permitted implementation and an owner decides whether to accept it.
Separate access from authority.
Discovering context, reading it, sending it to an AI service, proposing a change and accepting it have distinct permissions. CodeGraph’s design checks current authority for the action and protects connected discussions, relationships and derived context alongside source.
Check both the contribution and the combination.
Link each proposal to its requirements, starting revision and evidence. One agent may increase batch size while another adds workers: both changes can pass alone and exceed memory together. Interacting proposals need checks of the combined candidate.
05 / One model, different jobs
Make the work easier
for everyone it depends on.
Developers & technical leads
Change unfamiliar software with the context in reach.
Move from repeated searches and handoffs to connected dependencies, rationale and relevant tests.
Engineering & platform leaders
Build on what the organization already knows.
Find shared capabilities, make reuse decisions and preserve understanding as teams and implementations change.
AI platform teams
Use context deliberately across agents and sessions.
Retrieve compact task context, expand into sources and retain understanding. Compare total tokens, investigation time and accepted outcomes.
Product, design & domain experts
Carry the need through to the result.
Connect examples, designs and constraints to implementation and acceptance, so contributors can see what the work must accomplish.
Security & assurance teams
Know what supports accepting a change.
Connect affected requirements and dependency paths to the exact revision, checks and decisions under review.
Shared-capability owners
Let improvements travel without losing local control.
Understand who uses a capability, how it was adapted and which changes are relevant to each authorized consumer.
06 / Shared understanding, independent decisions
Keep the organization’s
purpose in the work.
Quality software depends on decisions across the organization. Our ambition is to connect the conversations, customer constraints, research and product choices behind those decisions across the applications where work happens.
A contributor should be able to understand the purpose, inspect the relevant detail, act within their authority and leave evidence others can check. When a requirement or assumption changes, follow its connections into the decisions and implementations that need another look.
Ideas that helped shape this approach
Ashley’s zoom-in/zoom-out approach draws inspiration from Paul Adams’s account of building software at Intercom, which connects strategy, objectives, projects and releases. Team of Teams connects shared understanding with empowered execution. CodeGraph’s ambition is to give people and AI a connected information structure that supports that way of working.
07 / Powered by 8DB · Native to the 8OS vision
The engine connects the data.
CodeGraph connects the work.
We’re building on 8DB to connect accepted software state, relationships and evidence in one omnimodal database. CodeGraph adds the software-specific meaning: what a capability does, how it is implemented, who depends on it and what supports changing it.
CodeGraph is our flagship specialist native app in the 8OS vision. The direction connects software work with Documents, Messaging, Identity and Projects, and makes 8RF reasoning available through the same operating environment.
Start with one valuable change