Twelve Claude sessions. One queryable ontology.
Give yourself the edge. In a knowledge graph, an edge is a relationship with meaning. SysEdge builds them across your entire codebase — stories realised by use cases, features verified by tests, decisions addressing standards — giving every parallel Claude Code session the edge of instant orientation over sessions that start from scratch. Measured: 96% fewer orientation tokens, four tasks, one real codebase.
Twelve sessions. One codebase. Zero shared memory.
Without SysEdge
- Each session re-reads the same source files to figure out what exists — 20–30% of every context window spent re-orienting
- Two sessions independently start work on the same feature. One gets merged, the other discarded.
- A test is added but nobody knows which feature it covers. Coverage looks green; the gap is invisible.
- An architectural decision is made in one session. The other eleven never see it.
- "What's left to do?" requires a human to reconcile eleven CONTEXT.md files.
With SysEdge
- Sessions query the graph: 30 seconds to know every feature, module, endpoint, and open task
start-enhancementflips a node to in-progress. Other sessions see it and route to different work.- Every test is linked by VERIFIES edges to the symbol, feature, and use case it covers — gaps surface as graph queries
- ADRs are nodes with ADDRESSES edges to 53 standards. Every session sees the same architecture state.
worklogreturns a prioritised queue per session. No human reconciliation required.
Full requirements traceability.
Every artefact from user story to unit test lives as a node. The graph is the specification.
A gap anywhere in this chain is visible instantly. There is no "I thought that was tested" — the graph either has the VERIFIES edge or it doesn't.
Why an ontology, not just a database?
A task tracker stores rows. An ontology stores meaning. In SysEdge, a Feature is not a ticket — it is a capability a Module provides. A UseCase is not a description — it is a user-visible flow that realises a Story. A Test's V-model tier is derived from which spec artefact it verifies, not from a tag. The 53 architecture standards are nodes with ADDRESSES edges to ADRs; a gap is a standard with no incoming edge. This is what makes the graph answer questions a flat database cannot without bespoke code.
Defined semantics matter most when twelve sessions share the graph simultaneously. "Which features have no use case?" or "which standards have no addressing decision?" are answered in one query — because the relationships encode what the words mean, not just how they were entered. Without an ontology, every session re-derives these answers from prose. With one, the graph derives them once and serves all sessions equally.
Orient without reading source.
Three commands replace ten minutes of file reading.
Fig. — SysEdge in action: the web visualiser navigating a real Go/TypeScript codebase (PocketBase), followed by the CLI demo showing briefing, worklog, stories, test-gaps, and export in under 60 seconds.
V-model coverage, enforced by the graph.
SysEdge implements the V-model: each specification artefact has a required verification artefact at the same abstraction level. Four tiers, each visible in the session briefing.
| Specification | Test tier | Technology | Owned by |
|---|---|---|---|
| User Story | e2e | Playwright — full cross-tool journey | master session |
| Use Case | usecase | Playwright — single UC flow | owning session |
| Feature / Module | integration | Python pytest — API contract | owning session |
| Symbol / Routine | component | Go test, vitest — function level | owning session |
Gaps at any tier are surfaced in test-gaps --instance X with the exact test file to create. No manual audit required.
Standards as graph nodes. Compliance as edges.
53 industry standards across Execution, Development, Operations, Security, and Infrastructure architecture are stored in the graph, sourced from 12-factor, OWASP, NIST, SRE practice, and cloud-native patterns.
Each standard links to an Architecture Decision Record (ADR) documenting how your codebase addresses it via an ADDRESSES edge. Standards with no addressing ADR are gaps — returned by a single query. An initial audit on a live codebase identified 14 genuine gaps and 8 compliant-but-undocumented standards in one session.
Your existing documents become graph nodes.
Import requirements documents, architecture specs, and use case files directly into the graph. Export the graph back as structured Markdown. Analyse for duplicate features, split candidates, and orphan nodes — all through Claude Code skills.
IMPORT SKILLS
/import-stories— User story documents → SysUserStory nodes/import-use-cases— UC documents → SysUseCase nodes + flows/import-requirements— Feature lists → SysFeature nodes/import-architecture— Arch docs → ADRs + standards/import-code— Existing symbols → inferred feature clusters
EXPORT & ANALYSE
/export --type stories— User stories as Markdown/export --type application-arch— Module/feature map/export --type technical-arch— ADRs + standards/export --type test-coverage— V-model coverage report/analyse-graph— Merge candidates, split candidates, orphans
Every import uses a review-and-confirm step — no silent writes. Near-duplicates are flagged before commit.
Zero-config setup via Claude Code scan.
The biggest adoption barrier is the initial seed JSON — defining your modules, features, and test packages. The /init-sysgraph skill solves this in one command. Included in the bootstrap kit.
Claude Code reads your directory structure, infers module boundaries from package layout, derives features from exported symbols, and generates a complete seed file — ready to load into Neo4j in under two minutes.
96% fewer orientation tokens.
Pays for itself in under a week.
We measured the tokens a Claude Code session reads before writing the first line of code — the orientation phase. Four tasks across a live 44-module Go/TypeScript codebase: two defects, two enhancements, ranging from a small service to a 2,500-line cross-layer feature.
| Task | Module size | Without SysEdge | With SysEdge | Saving |
|---|---|---|---|---|
| DEF-001 — MCP scope enforcement defect licmcp · small service · 1 file |
small | 21,929 | 1,348 | −93% |
| ENH-103 — Remove legacy impl-planner surface plan · 4 Go files + 1 TSX component |
medium | 31,467 | 1,683 | −94% |
| ENH-330 — Delegation inbox API endpoint manage · 2,889-line handler file |
large | 48,588 | 1,423 | −97% |
| ENH-200 — CreateActionDialog + reassign endpoint core · cross-layer: Go handler + TSX + API |
large | 53,114 | 1,086 | −97% |
| Average | 38,774 | 1,385 | −96% |
AT 10 SESSIONS/DAY · SONNET 4.6
orientation cost only · implementation tokens are equal
PAYBACK PERIOD · $149 BOOTSTRAP KIT
at 10 sessions/day. Faster at higher session counts.
token savings alone · coordination and coverage benefits not included
How we measured this ↓
We measured the orientation phase only — the tokens a session reads before writing any code. Implementation tokens (reading source to understand what to change, writing the fix) are equal in both paths and excluded from the comparison.
Without SysEdge: we listed every file a Claude Code session would realistically read to orient on the task — the root CLAUDE.md, the instance CLAUDE.md, the enhancements or defects file, and the relevant source files. File sizes are actual bytes from the live codebase.
With SysEdge: we captured the actual output of briefing --instance X, worklog --instance X, and show-enhancement --id ENH-NNN for each task, plus the instance CLAUDE.md (read in both scenarios).
Token estimate: len(text) / 4 — a conservative approximation for mixed code and prose. Claude's actual tokeniser (BPE) typically gives slightly fewer tokens for code-heavy content, so the real saving may be larger.
Caveat: the "without" scenario reads whole source files. A skilled session using Read with offset/limit on targeted sections would read fewer tokens — we estimate the honest real-world saving at 60–80% for medium and large modules.
All four tasks are real completed work on a live 44-module Go/TypeScript codebase. The codebase, measurement script, and raw outputs are included in the bootstrap kit.
Coverage as a graph query — not a percentage.
Coverage isn't one number; it's a shape across four V-model tiers. SysEdge maps every test to the spec artefact it verifies — e2e tests to user stories, Playwright flows to use cases, integration tests to features, unit tests to symbols. After one day of graph-guided sessions on a 12-instance system, 9 of 11 instances reached 100% integration coverage. 1,459 vitest tests were auto-scanned and 5,807 VERIFIES edges created with no manual mapping.
COVERAGE AFTER ONE DAY — 196 features across 9 active instances
| Instance | Features | cmp | int | uc |
|---|---|---|---|---|
| core | 40/40 ✓ | 5 | 40 | 20 |
| framework | 30/30 ✓ | 21 | 30 | 11 |
| manage | 35/35 ✓ | 35 | 35 | 35 |
| plan | 43/43 ✓ | 28 | 43 | 42 |
| platform | 13/13 ✓ | 13 | 13 | 13 |
| p1, licmcp, training, master | 35/35 ✓ | varies | 35 | varies |
| Total | 196/196 | 112 | 196 | 121 |
cmp=component/unit · int=integration/API · uc=UI flow per use case
5,807 VERIFIES edges · 7,470 tests · 98 endpoints linked
WHAT SESSIONS REPORTED
"Without the graph I would have written a new unit test and felt done. Now I can see the shape — integration tests validate API contracts but do not test component rendering or specific user flows."
— core session, FB-083
"I wrote tests specifically for 6 features with zero component coverage even though I hadn't touched those components directly."
— framework session, FB-063
"MOD-board 0/4 cmp makes visible a gap I would otherwise rationalise away — integration tests exist so it feels covered."
— plan session, FB-068
Language-agnostic graph. First-class scan for Go, TypeScript, Python, Java, and C#.
The graph, worklog, briefing, test coverage tracking, architecture standards, and all coordination features work for any language. Code symbol extraction and test scanning add richer navigational detail for supported languages.
Adding a new language scanner is one Python function (~20 lines). See INSTALL.md for the plugin interface.
Neo4j + a 3,000-line CLI + a skill file.
Components
- Neo4j Community (free) — the graph database
- sys_graph.py — CLI for all graph operations, 40+ commands
- sys_graph_viz.py — local web visualiser, drill-down navigation
- feature-graph skill — Claude Code skill file, governs all session behaviour
- Seed JSON — your project's module and feature definitions
Safety model
- Sessions use MERGE (never DELETE)
- Graph reset is a separate shell script — not accessible from Claude
- Instance-filtered seed auto-backs up before running
- VERIFIES edges snapshot before any seed — post-backup links preserved
- Sessions only write nodes within their declared instance scope
Free CLI. Pay for the visualiser and bootstrap kit.
The CLI gives you full graph power from the terminal. The bootstrap kit adds the web visualiser, Docker setup, auto-seed skill, and session templates — everything to be productive in an afternoon.
| Feature | Free CLI | Bootstrap Kit · $149 |
|---|---|---|
| FOUNDATION | ||
| Briefing, worklog, test-gaps per session | ✓ | ✓ |
| Scan code + tests (Go, TypeScript, Python, Java, C#) | ✓ | ✓ |
| Create + track enhancements, defects, user stories | ✓ | ✓ |
| V-model 4-tier coverage (component / integration / UC / e2e) | ✓ | ✓ |
| Backup + per-instance restore | ✓ | ✓ |
| MIT + Commons Clause licence + README + INSTANCES guide | ✓ | ✓ |
| BOOTSTRAP KIT ONLY | ||
| sys_graph_viz.py — web visualiser drill-down graph, entity editor, coverage tiers, export panel | — | ✓ |
| Export commands — stories, use-cases, application-arch, technical-arch, test-coverage | — | ✓ |
| Import skills — /import-stories, /import-use-cases, /import-requirements, /import-architecture | — | ✓ |
| Graph analysis — merge candidates, split candidates, orphan detection | — | ✓ |
| /init-sysgraph — auto-seed from working directory | — | ✓ |
| Architecture standards YAML (53 standards, 5 domains) | — | ✓ |
| Docker Compose + one-command setup (python3 setup.py) | — | ✓ |
| All Claude Code skill files + session role templates | — | ✓ |
| 12 months of updates + email support | — | ✓ |
Per repository · one-time · instant download · VAT included
20+ parallel sessions or custom language support — contact us.
The free CLI is MIT + Commons Clause — free to use for your own projects, including commercial software.
You may not sell the CLI itself as a product or service without a commercial licence.
The bootstrap kit is licensed per repository with 12 months of updates and support.
One licence covers unlimited team members and machines working on that repository.
Read the full licence conditions →
Running in four steps.
The bootstrap kit includes a Docker Compose file that starts Neo4j with the right configuration and a setup wizard that generates your initial seed JSON from your working directory.
Stop re-reading source files. Query the graph.
SysEdge came out of running a 12-instance Claude Code system — twelve parallel sessions, one shared codebase, no human in the loop for routine coordination. The ontology is what keeps the sessions coherent: shared meaning, shared state, shared next-actions. When the graph is the source of truth, sessions spend their tokens building, not exploring.