Planning Graph Delegation and Forking

Mechanism

Planning graph delegation is the transfer of speculative substructures from a parent agent's planning graph to a child agent's planning graph with re-scoped context. The forecasting engine supports this transfer so that a parent agent which constructs a planning graph with branches that exceed the agent's own capabilities or operational scope can move specific branches or sub-branches to child agents better positioned to evaluate and execute them. Delegation, forking, and inheritance are the three related mechanisms by which speculative content moves from a parent agent to a child agent's planning domain. None of them carries verified state: in every case the delegated content enters the child's planning graph domain, not its verified execution memory.

The unit that is delegated is a branch the parent agent has classified as delegable. A delegable branch is one that has passed slope validation and policy compatibility but that the parent's policy configuration or personality field identifies as better suited for delegation: the branch requires capabilities the agent does not possess but that are available through delegation, the branch involves a sub-problem within the specialization domain of an available delegate, or the agent's delegation preference trait indicates that the agent should delegate rather than execute the branch directly. Delegable branches are routed into the delegation, forking, and inheritance mechanisms described here.

The Delegation Package

Delegation operates by constructing a delegation package. The parent agent identifies a branch or sub-branch in its planning graph that is classified as delegable, and the parent agent's forecasting engine assembles a package comprising three parts. The first is the speculative content of the delegable branch: its mutation sequence, projected outcome, and evaluation metadata. The second is the delegation context: the parent agent's intent, the operational constraints that apply to the delegated branch, and the success criteria that the child agent must satisfy. The third is the re-scoped policy constraints: the subset of the parent agent's policy configuration that applies to the delegated branch, potentially augmented with delegation-specific constraints.

The delegation package is transmitted to the child agent through the standard delegation interface described in the cross-referenced execution disclosure. The speculative marker is preserved across the transfer. Because the marker is preserved, the delegated content enters the child agent's planning graph domain rather than its verified execution memory, maintaining the same structural separation between speculation and verified state on the child side that the parent maintains on its own.

Forking

Planning graph forking is the creation of multiple independent copies of a planning graph branch, each of which may evolve independently in different agents' planning graph domains. Forking enables parallel speculative evaluation. A parent agent may fork a branch and delegate each fork to a different child agent, so that multiple agents independently evaluate different approaches to the same speculative problem. The forks are independent: once created, each copy evolves within its own agent's planning domain without reference to the others.

The results of the forked evaluations are collected by the parent agent's executive engine. If the parent agent does not have executive engine authority, the results are collected by the zone-level executive engine instead. The collected forks are then compared to determine which fork produced the most favorable outcome. Forking thus pairs naturally with delegation: a single delegable branch becomes several parallel inquiries, and the parent recovers a comparison across them rather than a single delegated result.

Inheritance

Planning graph inheritance is the mechanism by which a child agent receives speculative content from a parent agent and integrates it into its own planning graph. Inheritance is not a passive copy. It is governed by three rules that re-situate the inherited branch within the child agent's own cognitive context, so that the child evaluates the branch as its own rather than carrying the parent's evaluation forward unchanged.

The first rule is trait override: the child agent's personality field may override specific trait dimensions of the inherited branch, causing the child agent's forecasting engine to re-evaluate the branch according to its own personality configuration. The second rule is mutation revalidation: the child agent's slope validation module and policy compatibility module re-evaluate the inherited branch against the child agent's own trust slope trajectory and policy constraints, potentially reclassifying the branch. The third rule is emotional dampening: the affective reinforcement tag of the inherited branch is attenuated during inheritance, preventing the parent agent's affective state from disproportionately influencing the child agent's evaluation. The dampening factor is specified by the delegation policy and ensures that the child agent evaluates the inherited branch based primarily on its own affective state rather than the parent agent's.

Speculative Containment Across the Boundary

Delegation does not breach the separation between the speculative planning graph domain and verified execution memory. Because the speculative marker is preserved when the delegation package crosses to the child agent, the delegated content arrives as planning graph content, not as committed state. The child agent cannot treat the inherited branch as verified reality. It can only evaluate it as one more speculative branch in its own planning graph, subject to the same slope validation, policy compatibility, and promotion requirements that apply to branches the child generated itself.

Mutation revalidation reinforces this property. The child agent does not accept the parent's slope projection or policy determination as authoritative. Its own slope validation module recomputes eligibility against the child's trust slope trajectory, and its own policy compatibility module re-checks admissibility against the child's policy constraints. A branch the parent classified as eligible may be reclassified by the child, because slope eligibility and policy compatibility are evaluated relative to each agent's own state, not transferred as fixed verdicts.

Relation to Coordination Without Schedulers

Delegation, forking, and inheritance fit within the forecasting engine's role as a coordination primitive that replaces centralized scheduling. A child agent begins evaluating a delegated branch not because a scheduler assigned it a task, but because the branch entered the child's planning graph and the child's own forecasting execution cycle evaluated it. The parent does not impose execution; it transfers a speculative substructure and re-scoped context, and the child decides, through its own cognitive evaluation, whether and how the branch advances.

Forking extends this to parallel exploration without a central planner. Multiple child agents each receive an independent copy of a branch and evaluate it within their own planning domains, and the executive engine aggregates the results by comparing the forked outcomes rather than by dictating which approach should be taken. Coordination emerges from the alignment and comparison of independently evaluated plans, consistent with the architecture's replacement of orchestration with forecasting-driven branch promotion.

Disclosure Scope

Planning graph delegation, forking, and inheritance, comprising the transfer of delegable speculative substructures from a parent agent's planning graph to a child agent's planning graph with re-scoped context, the delegation package of speculative content, delegation context, and re-scoped policy constraints transmitted with the speculative marker preserved, the forking of a branch into independent copies for parallel evaluation across multiple agents with results collected by the executive engine, and the inheritance rules of trait override, mutation revalidation, and emotional dampening, are disclosed in the cognition filing (U.S. Application No. 19/647,395 and its international counterpart) at Section 4.12. This article describes that disclosed mechanism. The scope extends to embodiments in which delegation, forking, and inheritance operate across different parent and child agent configurations and delegation hierarchies, provided the delegated content remains speculative planning graph content subject to the child agent's own slope validation, policy compatibility, and promotion requirements.