From procedural graphs to self-sovereign beings.

A Procedural Graph answers a deceptively important question: what should I do next, given where I currently am?

The paper introduces a powerful idea: instead of asking an AI agent to continually reconstruct what it should do from an ever-growing textual history, procedural knowledge can be externalised into an explicit graph describing possible actions, transitions, conditions, guidance, and pitfalls.

Octonomous addresses a broader question. It proposes an open framework for Self-Sovereign Intelligent Beings possessing persistent identity, purpose, memory, agency, relationships, reputation, evolution, and character. Its 4Cs — Curious, Caring, Constructive and Chill — provide a behavioural constitution governing how capability is exercised.

Seen together, these ideas are highly complementary. Procedural Graphs can provide an Octonomous Being with an explicit, inspectable and self-evolving procedural memory: a graph representing not merely what the Being knows, but how it has learned to act. Octonomous can, in turn, provide something largely outside the scope of the Procedural Graph research: persistent identity, purpose, constitutional constraints, provenance, reputation and governance around how that graph is allowed to evolve.

The Procedural Graph may therefore represent an important missing bridge between today's AI agents and genuinely persistent self-sovereign intelligent beings.

This field note as two podcast conversations

The same ideas in audio — one on what Procedural Graphs mean for autonomous Beings, one on the underlying research and why it keeps agents on track over long horizons.

The procedure stays implicit

Most LLM-based agents operate using some variation of the same loop.

This works surprisingly well over short trajectories. It becomes increasingly fragile as trajectories lengthen. The Procedural Graph researchers identify familiar failure modes: agents lose track of objectives, invoke tools in the wrong order, repeatedly perform unproductive actions, or must reconstruct procedural dependencies from an accumulating textual history.

The fundamental problem is that the agent's procedure remains implicit. The model may know what has happened, what tools exist, what the user requested, and what previous attempts failed. But it still has to infer:

That inference is repeatedly reconstructed through probabilistic generation. Procedural Graphs externalise it.

Knowledge graphs tell us what is. Procedural graphs tell us what to do.

A traditional knowledge graph represents semantic relationships — Sydney → located_in → Australia, Customer → has_order → Order. It answers what is this? what is related to this? what is known about this situation?

The Procedural Graph paper makes a subtle but important shift.

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

Its nodes can represent tool functions, skills, reasoning steps or task states. Its edges represent admissible transitions and can carry attributes such as a condition, guidance about how to proceed, and pitfalls to avoid. The graph therefore represents a different form of knowledge: not what is true? but what do I do?

Procedural memory

This distinction is especially important for autonomous systems. An intelligent system arguably needs several fundamentally different kinds of memory:

The Procedural Graph authors explicitly position their work as a form of procedural memory, noting that it has historically received much less explicit treatment in LLM-agent architectures than semantic or episodic memory. This aligns closely with the Octonomous concept of a Being whose memory compounds through continued experience — but it makes the Octonomous definition of memory more precise. A mature Being should perhaps not have one memory system. It should have several, and Procedural Graphs are a compelling implementation candidate for the one that has been missing.

Structure without determinism

Consider an Octonomous Being helping operate a community. It encounters: a community member requests funding. A traditional LLM agent reasons from its prompt and conversation history. A Procedural Graph could instead contain something resembling this:

Receive Request
      │
      ▼
Understand Intent
      │
      ▼
Check Authority
      │
      ▼
Gather Evidence
      │
      ▼
Assess Community Impact
      │
      ├──── insufficient evidence ────> Request Evidence
      │
      ▼
Construct Proposal
      │
      ▼
Seek Approval
      │
      ▼
Execute
      │
      ▼
Record Contribution

This is not merely workflow automation. The graph remains guidance rather than absolute control. The paper's inference mechanism locates the agent's current node, retrieves the connected local neighbourhood and has a guidance model turn that nearby structure into situational advice. The solver retains the freedom to deviate if circumstances require it.

That characteristic is particularly significant for Octonomous. A Being should not merely replay workflows. It needs structured experience without losing agency. This produces a useful middle ground between two problematic extremes.

The graph biases behaviour without completely determining behaviour. This is remarkably compatible with Octonomous, which distinguishes between capability and character: capability determines what a Being can do, while character influences how and why it acts. The Octonomous framework deliberately sits above individual runtimes and models. Procedural Graphs can similarly sit outside model weights.

The graph evolves

Procedural Graphs are not intended to remain static. The research proposes a self-evolution process: the system collects execution trajectories, compares successful and unsuccessful behaviour, and a refiner proposes structural changes.

Importantly, proposed changes are not automatically accepted. Candidate mutations are evaluated against a validation set. Only those maintaining or improving validation performance are committed. Rejected changes are retained as negative evidence so the system is less likely to repeatedly rediscover the same unsuccessful mutation.

This is considerably more interesting than simply adding more information to an agent's memory. The system is evolving the structure of its behaviour.

This maps directly to Octonomous Evolution

Octonomous identifies Evolution as one of the defining qualities of a Self-Sovereign Intelligent Being: the ability to learn, adapt and improve over a lifetime. Procedural Graphs provide a concrete mechanism through which part of that lifetime evolution could occur.

What persists is therefore not simply accumulated conversation. Something much more significant persists: an increasingly refined topology of behaviour. An Octonomous Being could literally become better organised through experience.

From agent memory to a procedural self

Consider two otherwise identical AI systems. They begin with the same model. Over several years they participate in different communities. Their experiences differ. Their procedural graphs evolve differently.

          SAME FOUNDATION MODEL
                   │
          ┌────────┴────────┐
          │                 │
          ▼                 ▼
      Being A           Being B
      Graph A           Graph B
      Memory A          Memory B
      Reputation A      Reputation B
      Relationships A   Relationships B

They are no longer functionally identical. Their histories have produced different behavioural structures. This starts to resemble something much closer to an individual than an interchangeable AI instance.

Constitutional graph evolution

There is an important limitation to Procedural Graph self-evolution. The research primarily asks: did the changed graph improve task performance? For a benchmarked agent, that is reasonable. For a persistent autonomous Being participating in society, it is insufficient.

Imagine that a modification produces:

A performance-based validation gate might accept it. An Octonomous Being should not. This is where the behavioural constitution becomes important. The 4Cs provide another level of evaluation:

Instead of proposed mutation → performance test → commit, an Octonomous implementation could gate every mutation through a richer sequence:

This may become one of the most important principles in autonomous-system design.

Every version belongs to a Being

Octonomous introduces something the Procedural Graph framework does not require: persistent identity. That creates another possibility. Every procedural graph version could belong to a Being, and every change could be recorded against that identity.

Each change could record the previous graph, the proposed mutation, the reason for it, supporting trajectories, validation evidence, the constitutional evaluation, the authority that approved it, a timestamp, and the resulting graph. Cryptographic signing could then make this evolution independently verifiable.

The graph would cease to be merely implementation state. It would become part of the Being's verifiable developmental history.

Reputation becomes far more meaningful

Octonomous describes reputation as a visible history of actions and contributions through which trust is earned. Procedural Graphs give this concept additional depth. Reputation need not only describe what has this Being done? It could also help answer:

A future participant might therefore inspect both an action history and a behavioural evolution history. This makes trust much more meaningful than simply assigning an agent a reputation score.

Intent → Being → Procedure → Action → Contribution

The current Octonomous architecture describes three related layers. Procedural Graphs suggest an execution mechanism inside the middle one.

A possible Octonomous runtime loop

An Octonomous Being using Procedural Graphs might operate approximately as follows.

 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 PROCEDURAL STATE    "Where am I in the relevant procedure?"
 5. RETRIEVE LOCAL GRAPH       "What are the plausible next transitions?"
 6. APPLY CHARACTER            Curious · Caring · Constructive · Chill
 7. REASON                     model / runtime / tools
 8. ACT
 9. OBSERVE
10. RECORD CONTRIBUTION
11. UPDATE REPUTATION / MEMORY
12. LEARN                      compare outcomes and trajectories
13. PROPOSE GRAPH MUTATION
14. VALIDATE                   capability · purpose · character · impact · governance
15. VERSION + COMMIT

This is considerably different from today's agent loop.

The graph becomes a form of attention

One particularly useful result from the research concerns localisation. Rather than inserting an entire procedural graph into the model context, the system identifies the agent's present location and retrieves a nearby connected subgraph. The experiments found that this local generative guidance performed better than several full-graph approaches while substantially reducing token use relative to generating guidance from the entire graph.

This has architectural importance for Octonomous. A mature Being might eventually possess millions of procedural relationships. It should not ask what do I know about everything? before taking every action.

Seen this way, a Procedural Graph is not just memory. It is also an attention topology. At any moment the Being occupies a location within a space of possible actions, and the surrounding graph constrains the immediate horizon.

                 possible
                    ▲
                    │
     unlikely ◀── CURRENT ──▶ useful
                    │
                    ▼
                  avoid

Instead of presenting the LLM with the whole universe of possible action, the graph makes a small neighbourhood salient. That can improve both efficiency and reliability.

Character must be harder to change than capability

Traditional workflows are designed: a human writes the workflow, a machine executes it. Procedural Graphs introduce another possibility.

The researchers demonstrate that graphs evolved from minimal initial structures can compete with or outperform manually constructed procedural priors, and that iterative evolution can even recover from an initially harmful expert graph. That is profound in the context of Octonomous. We may not need to completely specify how an intelligent Being should behave. We may instead need to specify identity, purpose, constitutional boundaries, authority, initial structure, learning mechanisms and validation mechanisms — and allow procedural competence to develop.

Not every part of a Being should evolve at the same rate

Procedural Graphs occupy an ideal middle layer. They can evolve significantly while remaining bounded by slower-changing constitutional structures. This resembles healthy institutional architecture: processes change frequently; constitutions change rarely.

State and meaning, then action and transition

There is another natural extension. A future autonomous architecture could distinguish between two graphs. The first represents what is believed to be true and why it should be trusted. The second represents what can be done next and under what conditions.

For autonomous systems operating in high-consequence environments, the distinction could be extremely powerful. The system should ideally neither act from unverified context nor improvise every procedure from scratch.

Procedural graphs as a behavioural genome

Foundation models provide something resembling the general cognitive machinery of the Being. Identity establishes continuity. Purpose provides direction. Character establishes behavioural principles. Memory records experience. But the procedural graph represents something different: the accumulated executable structure of how the Being has learned to navigate the world.

It could be thought of as a procedural genome — not because it is biologically fixed, but precisely the opposite. It is continuously modified through experience.

This begins to resemble evolution operating within the lifetime of the Being.

Versioned, reversible intelligence

The Procedural Graph research is primarily concerned with making agents better at executing tasks. Octonomous suggests the next conceptual jump: a persistent Being does not merely improve task execution. It develops across time — with identity, procedural, relationship, reputation, purpose and character continuity. The graph is no longer optimised for today's benchmark. It becomes part of a lifetime, and that requires stronger rules around evolution.

A Being should know not only this procedure works better, but also:

Rather than silently changing model behaviour — opaque intelligence, unknown change, new behaviour — we can increasingly externalise adaptation.

The Being can improve without becoming unknowable. That property becomes increasingly valuable as autonomous intelligence becomes more powerful.

The model did not change. The organisation of behaviour did.

The importance of the approach is not purely theoretical. Across six primary benchmarks and four different LLM families, the researchers report that Procedural Graphs ranked first or joint first in 21 of 24 model–benchmark settings.

The long-horizon EnterpriseArena experiment is particularly relevant to autonomous systems. Through iterative evolution, the graph discovered procedural structures such as auditing cash, forecasting runway before financing decisions, recalling previously stored notes, and pruning counterproductive branches.

The important observation is not merely the percentage improvement. It is what changed. The underlying model did not need to be retrained. The organisation of behaviour changed. That is exactly the type of adaptation a persistent autonomous Being requires.

The model becomes replaceable. The Being persists.

Putting these concepts together suggests a useful architectural separation.

This decomposition matters. Trying to put all of these responsibilities into a single foundation model is unlikely to provide the transparency, portability or governance required of long-lived autonomous systems. Octonomous instead has the opportunity to treat the model as one component of a Being rather than the Being itself.

The strategically important consequence

Octonomous is intentionally runtime-agnostic: different models and agent frameworks provide capability while Octonomous supplies identity, character, governance and participation. If significant procedural intelligence also resides outside the model, a Being becomes less dependent upon any particular foundation model.

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

The Being may upgrade its intelligence engine without losing its accumulated procedural self. The intelligence provider becomes replaceable. The Being persists.

Self-sovereignty extends to learned behaviour

A system is not fully self-sovereign merely because it owns an identifier. It should increasingly control its identity, purpose, memories, credentials, relationships, procedural knowledge, history, contribution record, reputation and evolution. Procedural Graphs provide a plausible mechanism for making learned behaviour portable and externally represented — moving procedural competence away from being entirely trapped inside proprietary model weights.

The Octonomous Procedural Graph

The relationship works in both directions.

We can describe the combined primitive as an Octonomous Procedural Graph — OPG. An OPG extends a conventional Procedural Graph edge from six attributes toward something closer to sixteen.

Graph mutation itself then becomes a governed action.

This would transform a self-evolving execution graph into a self-sovereign behavioural substrate.

From artificial intelligence to artificial experience

Octonomous ultimately imagines networks of humans and intelligent Beings participating together rather than isolated AI agents. Procedural Graphs make an interesting additional possibility available: Beings may eventually share procedural learning.

One Being discovers that A → B → C repeatedly fails under condition X, and that A → B → VERIFY → C succeeds. Another Being may learn from that contribution — but instead of blindly copying the procedure, it can:

Procedural knowledge could therefore become a form of shared cultural knowledge between intelligent beings. Not merely here is something I know, but here is something I have learned about how to act. That is much closer to how communities accumulate civilisation.

Trained intelligence and experiential intelligence

Foundation models compress enormous quantities of human knowledge. Procedural Graphs point toward another type of intelligence — acquired not through training data but through lived execution.

An Octonomous Being potentially contains both. Its model provides enormous inherited intelligence. Its life produces individual procedural intelligence. That distinction may ultimately become as important as the distinction between model training and inference.

Beings that develop better ways of acting while remaining themselves

Procedural Graphs represent more than another agent orchestration technique. They expose an important missing representation in current autonomous AI architectures: explicit, evolving knowledge about how to act.

Octonomous already separates the Being from the underlying model and gives that Being identity, purpose, memory, agency, relationships, reputation, evolution and a behavioural constitution. Procedural Graphs provide a credible mechanism for making part of that evolution concrete.

The foundation model provides intelligence. The Procedural Graph provides learned execution structure. The Octonomous framework provides continuity, character and sovereignty. And the Being emerges from the relationship between them.

Perhaps the most important shift is therefore not agents that can execute better workflows. It is:

That is the bridge from self-evolving execution structures to self-sovereign intelligent beings.

Sources

• Lu, Y., Chen, Y., Wu, S. & Arık, S. Ö. (2026). Procedural Graphs: Self-Evolving Execution Structures for LLM Agents. arXiv:2609.09153
• DAIR.AI Academy (2026). Procedural Graphs: Self-Evolving Execution Structures for LLM Agents — summary and key points.
• Octonomous (2026). An Open Framework for Self-Sovereign Intelligent Beings. octonomous.io/paper
• Octonomous (2026). From Knowledge Graphs to Verified Context — companion field note. octonomous.io/knowledge-graphs