THE PRODUCT · LIVING CODE GRAPH

Everything the agent was missing.

Three layers sit behind one MCP connection: a structural index of your repository, a durable memory of what your team decided, and — for enterprises — a governed pipeline that routes the right model to each step of delivery.

01 · Code index 02 · Memory layer 03 · Architecture 04 · Benchmarks 05 · Governed delivery

Start free See how it works

2A LIVING CODE INDEX · DOUBLE HELIX

AST GRAPH

01 · THE LIVING CODE INDEX

Not grep. Not vector RAG.

Tree-sitter parses 12 languages into a typed graph, then Helixor compiles structure on top of it. The agent asks a question and receives typed answers — definitions, usages, bonds — instead of a stack of files to re-read.

Definitions & usages

Every symbol, where it lives, and everywhere it is touched.

Control & data flow

How execution and values actually move through the repo.

Weighted bonds

Coupling strength between symbols, so blast radius is rankable.

Motifs & rules

Positive and negative patterns scored against your architecture rules.

Commit-aware freshness

Git diffs are spliced into the index as they land, so the agent knows its knowledge is stale before it answers instead of confidently guessing.

Living Code Index

COMPILED

$ helixor index ./ --full

indexed my_project locally: 38 files, 693 nodes, 251 edges

local artifact: ~/my_code/my_project

codebasemy_project

graph density693 nodes / 251 edges

languages parsed12 supported

freshnessclean (git diff spliced on edit)

quality score97 / 100 (Grade A)

motifs & rules3 findings (0 critical · 3 low)

artifact lives on this machine · zero source code uploaded

02 · PERSISTENT ENGINEERING MEMORY

The half nobody else ships: memory that outlives the session.

Durable, depth-aware TODO stacks and workspace channels over MCP that survive sessions, machines and IDEs. Claude and Codex post into the same channel, pin decisions and hand work off to each other — auditably, under each developer's real identity.

Identity is server-derived and fails closed: a client cannot claim to be another author. Every usage stat is a measured counterfactual with its method printed — tokens served vs. avoided, file reads avoided, stale-index catches. No invented "productivity" numbers.

codex · helixor mcp

todo ▸ stack "payments-refactor" · 4 deep · shared

1. split settlement writer done

2. backfill idempotency keys in progress

3. retire legacy webhook path

channel ▸ claude pinned "idempotency key = order_id + attempt"

handoff → codex · author verified server-side

Session start

"What's stale in this repo?" · "What is Bob working on?"

During work

"Explain this flow." · "What violates our architecture?"

Session end

"Update my stack and post a 3-line summary to the team channel."

Friday

"What has Helixor done for us this week?"

PROVEN IN PRODUCTION

From Agent Action to Live Desk Visibility

When an agent writes to a TODO stack or design record via MCP, the change is immediately synchronized and visible in the companion's Local Desk — persistent, depth-tracked, and ready for handoff.

1. Agent Stack Creation · Codex brain.todo push

Codex creating a durable Helixor TODO stack from code review findings

Codex converts code review remediations into a 3-item durable stack (todo_7e9aa...) linked to the design spec.

2. Real-Time Operations Desk · 127.0.0.1:18733/desk STATE PLANES

Helixor Local Desk displaying active stacks, phase status, and state planes

The Local Desk tracks completion across 14 stacks, showing phase status, linked designs, and authority planes in real time.

03 · ARCHITECTURE

Code stays local. Memory is what's shared.

Hub and spoke. Each developer's machine indexes its own repositories, and the source and the index never leave it. What the hub carries is the engineering memory — designs and TODO stacks, channels and identity — hosted as SaaS or on your own Enterprise servers. No VPN, no port forwarding. The hub deploys once in about five minutes and scales to zero; each developer onboards in about five.

Local — the spoke

Source code
The structural index
Parsing, scoring, rule checks
Local git freshness

Shared — the hub

Designs and pinned decisions
TODO stacks and channels
Identity and attribution
SaaS or Enterprise servers

Hub deploy ~5 min, scales to zero

Developer onboard ~5 min

Networking No VPN, no port forwarding

Hub hosting Helixor SaaS or your servers

04 · MEASURED, NOT CLAIMED

Same task, same agent, same repo.

One real question

Without Helixor

With Helixor Code

Agent time

3:17

0:13

Tokens into the model

98.6k

7.4k

Tool rounds

14.5× faster · 13.3× leaner

3.9×

Faster index build at repo scale — 19.5s vs 75.6s.

8.8×

Smaller query payload — 169 vs 1,492 tokens.

25,000×

Leaner than raw context, budget-bounded.

A naive graph artifact can end up larger than the source it indexes — 25.5M tokens on a 10.16M-token repository. Helixor answers are demand-proportional and capped by a token budget, so cost does not grow with the question.

05 · ENTERPRISE · GOVERNED DELIVERY

One pipeline, the right model for each step.

Checkpointed, resumable, and artifact-backed at every step. This is what "AI that enforces your engineering standards" actually looks like. Each model call runs on your key, at your rates.

Talk to us about orchestration →

intake → triage → plan → human approval → implement → tests → review → release notes

sdlc.safe_change_delivery.v1 — every step checkpointed, retryable (3×), resumable, and producing a required artifact.

SDLC IN ACTION

Implementing a Multi-Agent SDLC

You can implement a multi-agent SDLC across your workflow. While each stage here was prompted manually by the developer rather than run autonomously, shared Helixor state kept the exact same project (mobile-book-tracker-v1) consistent across Antigravity, Claude, and Codex.

01. Plan · Antigravity design_...