The market spent July discovering that agents should think in graphs. It is right.

The label is new — roughly three weeks old at meme scale — but the two practices under it are not. One is orchestration: design an agentic system as an explicit directed graph, typed nodes doing work and typed edges routing state, instead of a while-loop with tools. The other is memory: knowledge graphs, typed-edge retrieval, bi-temporal stores. Both are decades-old computer science wearing a new hat, and the skeptics who say so are correct. They are also beside the point: the reason the label caught on is that the underlying observation is true. Structure beats vibes.

We have no priority claim to make on the orchestration half. LangGraph and its neighbours got there first and got there well. What we have been building is the half nobody has named yet.

The question the trend hasn't answered

Everyone in this conversation has nodes and edges. What none of it has is an answer to a simpler question: when this graph tells you something, what makes it true?

The trend already measures itself honestly here, and the numbers deserve to be taken seriously: on GraphRAG-Bench, graph retrieval beats vector retrieval decisively on multi-hop and temporal reasoning (53.4% vs 42.9%, and 58.1% vs 21.7%), at much higher token cost. But notice what kind of numbers those are. They are hit rates. A hit rate is the correct measure for probabilistic retrieval — and it is a property of the method. Better resolution moves it. Nothing moves it to 100.

We are not on that curve. Not because we resolve entities harder — because we are doing a different thing. Symbolic retrieval over a governed graph either grounds an answer end to end or it abstains:

Graph engineering gives agents structure. Governance is what makes the structure load-bearing. And governance has a price — which we can state exactly, because we measured it.

We deliberately built the slow one

We benchmarked our proof-carrying engine against engines that run the same derivations without carrying proofs — the Datalog engines ascent and crepe, and the RDF store oxigraph — on identical rule closures, derived-fact counts asserted equal. They beat us by one to three orders of magnitude. Deriving a million facts takes our engine about four seconds; ascent does the same closure in 25 milliseconds (~163× faster), crepe in 87 (~47×), oxigraph in 189 (~22×). On a quadratic closure the worst gap is ~1,264×. These are our own measurements, from our own baseline battery, and we label them as exactly that.

We publish the comparison willingly, because the overhead is the design. Ours is the only engine in it where every derived fact carries a proof — the rule that produced it and the premises it stands on — so every answer can show its work, and anything that cannot is refused rather than asserted. One to three orders of magnitude is the price of the receipt. We chose it on purpose.

The number we actually watch is not a speed. It is false_proofs = 0 across 100,000 synthetic patients and 3.1 million derivations — a standing regression gate, not a benchmark run from a good day. And when the graph cannot ground an answer, it says so. From that artifact's own recorded verdict, verbatim: "High abstention on the NCCN/WHO guidelines is CORRECT — the JNC8-shaped cohort cannot resolve their value sets, so the engine abstains rather than guessing."

The model acquires; the provable path answers

The obvious objection: a graph that answers only what it can prove doesn't know much on day one. Correct — and that is where the LLM belongs. When there is no symbolic knowledge to answer from, the model reads the source prose and the graph learns from it: explicit, cited, symbolic knowledge, extracted on demand. From then on, that question is answered from the provable path, citations attached. Each side does what it is good at — the model acquires, the graph answers.

And the governance line runs through the middle of our own system, not just around it: knowledge that entered through the model is stamped certifiability_class="neural" and is barred from the proof tier. Our own hybrid is not allowed to launder its neural half into its proven half. That is what we mean by governance — not a philosophy statement; a transition the store refuses.

What we published, and what we deliberately didn't

Rather than write an essay about this, we published specifications. Eight of them are live at github.com/Congruentsys/commons under CC-BY-4.0 — implementation-free, so the point is that you can reimplement them, including if you never pay us.

They fall in two groups. The formats: the board/item/relation format with typed, directional edges carrying domain, range and inverses; the Yurtle document format; the conformance-bundle shape; the evidence-envelope type. The methods: hypothesis-driven development as a working discipline, and the honesty-dashboard and claims-ledger method — the one anyone can run to hold us accountable.

Every one carries a Conformance section: a list a third party can falsify by construction. That is the line between a published specification and a marketing claim.

Now the part that matters more than the list. The specifications above are the formats and methods tranche. They are not the governance model. The never-fabricate semantics, the epistemic-mode contract, and the refusal specification — the concept-bearing pieces, the ones this post argues the field actually needs — are withheld from this tranche by design, and the commons says so in its own front matter rather than hoping nobody checks.

We would rather publish the formats now and the concepts when they are stable than ship a governance spec that moves under people who adopt it. If you came here for the authority-axis specification, it is not there yet. That is the honest state, and it seemed better to say it in the post than to let you find out in the repository.

Where the engine fits

The work-graph engine our own fleet runs on is public and MIT-licensed: arrow-kanban — Arrow-native with Parquet persistence, typed relationships, a single-writer NATS server mode and a durable event log. Three of the eight specifications describe things it implements: the item and relation format, the graph-native proposal and review model, and the wire protocol.

That engine is how we run our own organisation as a governed graph — not the agents' control flow, but their work products. Hypotheses, experiments, proposals, reviews, decisions and code are one queryable graph with provenance on the edges. Reviewer-is-not-author is not a convention we ask people to follow; it is a transition the store refuses.

The reasoning core stays closed. The formats — where ecosystem gravity and standards power actually live — are shared.

If you are building on graphs right now

Two suggestions, neither of which requires anything of ours.

Ask what your graph does when it cannot ground an answer. If the response is "returns its best guess," you have a confidence problem that better retrieval will not fix, and you will find it in production rather than in evaluation.

And publish your falsification instructions alongside your claims. We publish ours — the claims-ledger method is spec 06, and the numbers in this post are registered under it, including the ones that say we are three orders of magnitude slower than the alternatives. It costs a paragraph. It is the cheapest credibility available, and in a field this loud it is going to start being the price of entry.

That discipline should not stop at engineering claims. The grandest claims in this field — "it reasons," "it is getting more general" — are the least falsifiable, so the yardstick we grade ourselves against is public too: acf-framework (MIT), an AGI certification framework of twelve capability dimensions with falsifiable measures mapped to each, stored as a graph you can query. How our own systems score against it, version over version, is on our research page.

The specifications are published in Congruentsys/commons. Corrections and questions are welcome as issues — including, especially, the ones that tell us where we were unclear.