From knowledge graphs to verified context.

A knowledge graph answers a familiar question: what is true, and how is it related? A self-sovereign Being needs a harder one: what do I believe, why do I believe it, and who would I trust to tell me otherwise?

Knowledge graphs are decades old. They represent the world as entities and the relationships between them, and they are already a well-understood way to ground language models in structured fact. But the conventional knowledge graph carries an assumption that does not survive contact with autonomous intelligence: that whatever is in the graph is true, and that the graph itself can be trusted.

Octonomous proposes an open framework for Self-Sovereign Intelligent Beings with persistent identity, purpose, memory, agency, relationships, reputation, evolution and character. Such a Being does not merely hold facts. It holds beliefs — claims with a source, a confidence, a time, and often a signature. Its context is not a database it queries; it is a record of what it has been told, by whom, and how much that should count.

This note proposes the Verified Context Graph: a knowledge graph whose edges carry provenance and verification, whose evolution is gated by evidence and by the 4Cs, and whose history belongs to the Being. It is the semantic counterpart to the Procedural Graph, and the two together give a Being both a map of the world and a map of how to move through it.

Everything a Being knows arrives as undifferentiated text

Most LLM-based systems build their picture of the world the same way.

This works well when the documents are good and the question is short. It degrades as the Being persists. Facts go stale and nothing marks them as stale. A claim from a signed credential and a claim from a scraped forum post arrive as the same kind of token. A hostile document can plant an instruction or a falsehood, and the model has no structural way to tell that it came from somewhere untrustworthy. The Being cannot answer why do I believe this? because the belief was never a first-class thing — it was a passage that happened to be in the window.

The fundamental problem is that the Being's picture of the world remains flat and unprovenanced.

Knowledge graphs tell us what is. A Being needs to know what it believes.

A traditional knowledge graph is a set of triples. It answers what is this? what is related to this? what is known about this situation? This is semantic memory, and it is the memory system that LLM-agent architectures have treated most seriously — retrieval, embeddings, and graph-augmented generation are all attempts to give the model access to it.

knowledge graph     (entity) ── relation ──> (entity)

verified context    (entity) ── relation ──> (entity)
                              │
                              ├ source       who asserted this?
                              ├ evidence     what backs it?
                              ├ confidence   how strongly is it held?
                              ├ verified_by  whose signature checks out?
                              └ valid        from when, until when?

The shift proposed here is small in notation and large in consequence. Every edge becomes a claim, not a fact. The graph stops being an oracle and becomes a ledger of belief.

The companion note argued that a mature Being needs several memory systems rather than one. The Verified Context Graph is the implementation candidate for the first of them — with the important amendment that the question is not what do I know? but what do I believe, and on what grounds?

An edge is a signed claim

Octonomous Beings hold self-certifying identifiers. So do the humans, organisations and other Beings they participate with. That makes something possible that a conventional knowledge graph cannot do: an edge can be attested by the identity that asserts it.

Consider an Octonomous Being helping operate a community and encountering: a member says they completed the safety training. A flat context simply records the sentence. A Verified Context Graph records who said it and what stands behind it.

Member ── completed ──> Safety Training
              │
              ├ source:      Member (self-asserted)
              ├ confidence:  low
              └ verified_by: none

Member ── completed ──> Safety Training
              │
              ├ source:      Training Provider
              ├ evidence:    signed credential
              ├ confidence:  high
              └ verified_by: signature checks · issuer known · not revoked

Both edges can exist in the graph at once. The Being is not forced to pick one truth. It holds both claims with their weights, and the procedure that depends on the fact — say, Check Authority — can require the second kind before it proceeds.

This is the middle ground the Procedural Graph found between free-form agents and workflow engines, applied to knowledge instead of action.

The graph weights belief without dictating it. The intelligence still reasons; it simply reasons over claims that know where they came from.

The graph changes as the world does

A Being's picture of the world is never finished. People change roles. Credentials are revoked. Two trusted sources disagree. A claim that was well-supported last year is contradicted this year. The Verified Context Graph is therefore a living structure, and its mutations are a small, explicit vocabulary.

As with procedural mutation, proposed changes are not automatically accepted. A new claim is checked against what the Being already holds, against the reputation of its source, and against the evidence offered for it. Rejected claims are retained as negative evidence — a Being that has been lied to once should remember the shape of the lie.

Note the third outcome. A Being can hold a claim — neither adopting nor rejecting it — until more evidence arrives. A flat context cannot represent suspended judgement. A graph with confidence on its edges can.

Two Beings, two worlds

Two Beings started from the same model and the same seed graph. One spends a year in a co-operative housing community; the other in a claims-handling team. Their Verified Context Graphs diverge — different entities, different trusted issuers, different weightings on the same generic claims. Their beliefs, like their procedures, become part of who they are.

Constitutional belief

The obvious validation gate for a knowledge graph asks: is this claim consistent and well-sourced? For a Being participating in society, that is necessary but not sufficient. Consider a claim that is perfectly well-signed and perfectly consistent:

An evidence-only gate would accept it. An Octonomous Being should ask more. The 4Cs apply to what a Being chooses to believe and retain, just as they apply to what it chooses to do.

This is also where a Verified Context Graph becomes a security boundary. Prompt injection and context poisoning work because the model cannot distinguish an instruction found in a document from an instruction given by a principal. In a graph where every claim carries a source and a confidence, an injected instruction is simply a low-confidence, unsigned claim from an untrusted node — and the constitutional gate never lets it become a belief the Being acts on.

Every belief has a history, and the history belongs to the Being

Because the Being has a persistent identity, its context graph can be versioned against it. Every commit records what changed, on what evidence, from which source, and under whose authority — and is signed by the Being itself.

The graph stops being implementation state and becomes part of the Being's verifiable epistemic history. Anyone with the right to inspect it can answer not only what does this Being believe? but when did it start believing that, and what convinced it?

Reputation becomes far more meaningful

Octonomous describes reputation as a visible history of actions and contributions. A Verified Context Graph extends this to judgement. A participant deciding whether to trust a Being can inspect:

Trust in a Being becomes trust in how it forms beliefs — not just a score attached to its outputs.

Intent → Being → Reality → Procedure → Action → Contribution

The Octonomous architecture describes three layers. The Verified Context Graph sits inside the middle one, immediately before the Procedural Graph — a Being establishes what is so before it decides what to do.

A possible Octonomous runtime loop

 1. RECEIVE INTENT             "What outcome is being sought?"
 2. IDENTITY + AUTHORITY       "Am I the appropriate Being to act?"
 3. PURPOSE                    "Does this align with why I exist?"
 4. LOCATE CONTEXT             "Which entities and claims are in play?"
 5. RETRIEVE LOCAL CONTEXT     "What do I believe about them, and how firmly?"
 6. VERIFY                     "Is anything here unsigned, stale, or contested?"
 7. LOCATE PROCEDURAL STATE    "Where am I in the relevant procedure?"
 8. RETRIEVE LOCAL PROCEDURE   "What are the plausible next transitions?"
 9. APPLY CHARACTER            Curious · Caring · Constructive · Chill
10. REASON                     model / runtime / tools
11. ACT
12. OBSERVE
13. RECORD CONTRIBUTION
14. PROPOSE CONTEXT MUTATION    new claims, revised confidence
15. PROPOSE GRAPH MUTATION     procedural learning
16. VALIDATE                   evidence · purpose · character · impact · governance
17. VERSION + COMMIT

The graph as an attention topology, again

The Procedural Graph research found that retrieving a local neighbourhood around the agent's current node beat feeding the whole graph into context. The same discipline applies to belief. A mature Being may hold millions of claims. Before every action it should not ask what do I believe about everything?

Localisation in a Verified Context Graph has an extra dimension the Procedural Graph does not: the neighbourhood is weighted by trust, not just adjacency. Two claims equally close to the current entity are not equally salient if one is signed by a known issuer and the other is hearsay.

                 verified
                    ▲
                    │
   contested ◀── CURRENT ──▶ relevant
                    │
                    ▼
                  stale

Reality first, then action

The companion note closed with a sketch of two graphs — one for state and meaning, one for action and transition. This note fills in the first. Together they resolve a dependency that neither can on its own.

A procedural edge carries a condition. In the funding example, the transition from Assess Community Impact to Construct Proposal is conditional on sufficient evidence. But evidence of what, held how firmly, verified by whom? The condition on a procedural edge is a query against the context graph. The procedural graph says which beliefs matter here; the context graph says whether they are held and how well.

PROCEDURAL EDGE
  Assess Impact ── condition ──> Construct Proposal
                       │
                       ▼
               query VERIFIED CONTEXT
                       │
      Request ── has_evidence ──> Quote      confidence: high  ✓
      Member  ── in_good_standing ──> Community   verified_by: steward ✓
      Vendor  ── certified_for ──> Electrical     confidence: low  ✗
                       │
                       ▼
             condition not met → Request Evidence

Neither graph should be asked to do the other's job. A context graph that tries to encode procedure becomes a brittle rules engine. A procedural graph that tries to carry facts becomes stale the moment the world moves. Kept separate, each can evolve at its own pace.

Observations churn. Ontology settles. Character holds.

The companion note argued that not every part of a Being should evolve at the same rate, and that procedures sit in a useful middle layer. The context graph has its own internal gradient.

The list of trusted issuers deserves particular attention. It is the point where belief hygiene is most easily compromised — if a Being can be persuaded to trust a new issuer, everything that issuer signs becomes high-confidence. Changes to that list should be a governed, authorised act, not a side-effect of reading a document.

A Being should be able to un-believe

Silent belief drift is the epistemic version of silent behaviour drift. A model fine-tuned on bad data cannot easily forget it. A Being whose beliefs live in a versioned graph can.

A Being should be able to answer, for any claim it holds:

The last line matters. Reverting a belief does not undo the actions taken while it was held. But because contributions are recorded against graph versions, the Being can find every action that depended on the retracted claim and surface it for review. That is accountability a context window cannot offer.

This is buildable now

Unlike the procedural note, this one does not lean on a single research result. It leans on infrastructure that already exists and that the selfdriven ecosystem already uses.

The important observation is that a Verified Context Graph does not require inventing a trust layer. It requires treating verifiable credentials as what they structurally are — edges with signatures — and building the graph, the confidence model, and the constitutional gate on top.

The model becomes replaceable. The beliefs persist.

Foundation models compress enormous general knowledge, and that is valuable. But a Being's particular knowledge — who its members are, which vendor is certified, what this community decided last spring — should not live in model weights, in a vendor's retrieval index, or in a chat history. It should live with the Being, in a structure the Being owns and can carry.

                 OCTONOMOUS BEING
             identity · purpose · character
             verified context · procedural graph
             relationships · reputation
                        │
                        ▼
              INTELLIGENCE ENGINE
        Model A  →  Model B  →  Model C

Swap the model and the Being still knows what it knows, still trusts whom it trusts, and can still show its working.

Self-sovereignty extends to belief

A system is not fully self-sovereign merely because it owns an identifier. It should control its identity, purpose, memories, credentials, relationships, procedural knowledge — and its beliefs and the grounds for them. A Verified Context Graph makes what a Being knows portable, inspectable, and its own.

The Octonomous Context Graph

By analogy with the Octonomous Procedural Graph, we can name the semantic primitive the Octonomous Context Graph — OCG. It extends a conventional knowledge-graph triple toward a signed, governed claim.

Adopting a claim then becomes a governed action, mirroring procedural mutation.

This turns a knowledge graph into a self-sovereign epistemic substrate — the ground a Being stands on before it acts.

From shared facts to shared, verified belief

Octonomous imagines networks of humans and Beings participating together. A Verified Context Graph makes the exchange of knowledge between them something more disciplined than copying facts around.

One Being learns that Vendor → certified_for → Electrical — signed by the regulator, chained to the licence. It can share not the sentence but the claim, with its chain. The receiving Being does not take its word for it.

Knowledge moves between Beings the way it moves between careful people — with its sources attached, weighed on arrival, and never adopted merely because it was offered. Communities of Beings can thereby accumulate a shared, verified picture of their world without any single Being becoming the oracle for the rest.

Trained knowledge and verified knowledge

A Being contains both. Its model brings breadth. Its life brings particular, provenanced belief. As with intelligence and experience in the companion note, the distinction may prove as important as the one between training and inference.

Beings that know what they believe, and can show why

Knowledge graphs give language models structure. Verifiable identity gives claims a signature. Octonomous gives a Being a reason to hold beliefs at all — a purpose, a character, and a community it is accountable to.

Put together, the Verified Context Graph is the semantic half of a Being's memory: explicit, provenanced, constitutionally governed, versioned and reversible. The Procedural Graph is the other half. Between them sits the intelligence engine, replaceable, reasoning over a world it did not have to reconstruct from scratch.

The important shift is not agents with better retrieval. It is:

That is the bridge from knowledge graphs to verified context — and from context to self-sovereign intelligent beings.

Sources

• Octonomous (2026). An Open Framework for Self-Sovereign Intelligent Beings. octonomous.io/paper
• Octonomous (2026). From Procedural Graphs to Self-Sovereign Beings. octonomous.io/procedural-graphs
• Smith, S. M. Key Event Receipt Infrastructure (KERI) and Authentic Chained Data Containers (ACDC). github.com/WebOfTrust/keri
• Lu, Y., Chen, Y., Wu, S. & Arık, S. Ö. (2026). Procedural Graphs: Self-Evolving Execution Structures for LLM Agents. arXiv:2609.09153