Capability-Bounded Predictive Planning

Mechanism

Capability-Bounded Predictive Planning, as defined in Chapter 6 of the cognition patent, integrates the canonical capability envelope into the planner's state-generation step. Conventional planners enumerate successor states by applying every action permitted by the action grammar and then score the resulting states under a value function. The mechanism disclosed here interposes a capability filter between successor generation and successor scoring: any successor whose preconditions exceed the current envelope, on any dimension, is pruned before it enters the scoring frontier.

The filter is not a soft penalty applied to the score. It is a structural exclusion: the pruned successor never appears in the search tree, never consumes scoring compute, and never contributes to the policy distribution returned to the executor. This is consequential because soft-penalty approaches preserve the option that a sufficiently high reward will overcome the penalty, which produces planners that propose actions outside their competence whenever the reward landscape is steep enough. Structural exclusion eliminates this failure mode by construction.

The mechanism further shapes the planner's compute budget on the basis of demonstrated competence rather than nominal capability. Demonstrated competence is a separate field, derived from the agent's lineage, that records the rate at which prior plans on similar tasks have completed within their declared envelope. When demonstrated competence is high for a task class, the planner is permitted to extend its horizon, widen its branching factor, and deepen its lookahead. When demonstrated competence is low, the planner is restricted to shallower searches that match the agent's track record. The relationship between competence and compute is monotonic and declarative; the planner does not adjust its own compute budget on the basis of mid-search heuristics.

The combined effect is that the planner does its work over a feasibility-bounded state space using a competence-scaled budget. Both bounds are derived from canonical fields, both are recorded in lineage, and both are reproducible from policy and the observed envelope and competence values.

A subtle but consequential property of the disclosed mechanism is that the capability filter operates on successor preconditions rather than on successor identities. Two successors that arrive at the same nominal action label may have different preconditions, depending on the state from which they were generated, and the filter evaluates each instantiation independently. This means the planner does not rely on a static action whitelist; it relies on the dynamic intersection of each successor's preconditions with the current envelope. The same action may be feasible from one state and infeasible from another within the same plan, and the filter handles the distinction without operator intervention.

Demonstrated competence is computed from a structured statistic over completed plans, not from a raw success counter. Each completed plan contributes to the statistic with a weight that reflects how closely the plan's executed trajectory matched its predicted trajectory, with an additional weight on whether the plan exited within its declared envelope or required mid-execution contraction. A plan that succeeded only by drifting outside its declared envelope contributes less to demonstrated competence than a plan that succeeded inside its declared envelope, even though both produced the same nominal outcome. This weighting rewards plans whose forecasts were honest about the agent's limits.

Operating Parameters

The capability filter accepts a per-dimension tolerance that defines how strictly successors must lie within the envelope to survive pruning. A zero tolerance prunes any successor whose preconditions match the envelope boundary exactly; a positive tolerance permits successors that fall slightly outside, with the offending dimension flagged for downstream review. The tolerance is a policy parameter and is recorded with each pruning decision in lineage.

The competence-to-compute mapping accepts a horizon ceiling, a branching ceiling, and a depth ceiling, each as a function of demonstrated competence. The function is monotonic and is typically expressed as a piecewise-linear schedule with declarative breakpoints. A minimum compute floor ensures that even at zero demonstrated competence, the planner performs enough work to produce a one-step policy; this prevents the planner from collapsing to a no-op when competence has not yet been established.

The mechanism also accepts a competence-window parameter that defines how far back in lineage the demonstrated-competence statistic is computed. Short windows make the planner responsive to recent successes and failures; long windows make the planner resistant to noisy single-task outcomes. The choice is policy-governed and may be configured per task class.

Alternative Embodiments

In one embodiment, the capability filter is applied only at the root of the search tree, pruning the agent's first action against the envelope and permitting the rest of the search to proceed unconstrained. In another embodiment, the filter is applied at every node, pruning every successor at every depth. The two embodiments differ in compute cost and in fidelity; both are within scope.

In a further embodiment, the demonstrated-competence statistic is computed not from the agent's own lineage but from a fleet-wide aggregate over peers performing similar tasks. This embodiment is appropriate for newly deployed agents that have not yet accumulated personal lineage. In yet another embodiment, the competence statistic is computed per task class, with separate windows and breakpoints per class, allowing an agent to plan deeply in domains where it is competent and shallowly in domains where it is not.

The mechanism is also embodied in planners that produce multiple candidate plans and select among them. In such embodiments, the capability filter is applied to each candidate independently, and the competence-scaled compute budget is allocated across candidates in proportion to their pre-search priors.

Further embodiments support a graduated tolerance schedule that tightens with depth: shallow successors are evaluated with a permissive tolerance, allowing exploratory expansion near the root, while deep successors are evaluated with a strict tolerance, ensuring that any committed leaf falls cleanly inside the envelope. Yet another embodiment substitutes a probabilistic envelope, in which each dimension is represented as a distribution rather than a scalar bound, and the filter rejects successors whose preconditions exceed a configurable quantile of the distribution. The probabilistic embodiment is appropriate for envelopes whose constituent measurements carry calibrated uncertainty, while the scalar embodiment is appropriate for envelopes derived from policy invariants.

Composition with Other Mechanisms

Capability-Bounded Predictive Planning consumes the canonical capability envelope produced by the broader capability-awareness machinery. It is therefore composable with the network-pressure contraction mechanism: when network pressure contracts the envelope, the planner immediately prunes successors that the contracted envelope no longer supports, without any explicit notification path between the two mechanisms. The composition is mediated entirely through the canonical envelope.

The mechanism also composes with the confidence-governance machinery of Chapter 5. The competence statistic that scales planning compute is one of the inputs to the confidence computation, but the planning mechanism does not consume confidence directly. This separation prevents the planner from second-guessing the authorization layer: the planner produces a plan within its competence-scaled budget, the authorization layer decides whether to execute it, and the two decisions are governed by independent policies.

Composition with the agent's lineage subsystem is also material. Each pruning decision, each compute-budget assignment, and each candidate-plan score is recorded with its policy version, its envelope snapshot, and its competence-window snapshot. The lineage record is sufficient to reconstruct not only the executed plan but also the alternatives that were pruned, which supports counterfactual analysis. An operator can ask, after the fact, what plans the agent would have considered had the envelope been larger, and the lineage record answers the question without requiring a re-run of the planner.

Finally, the mechanism composes with declarative goal specifications. A goal that is itself outside the current envelope is rejected at the planner's entry point rather than producing a fully searched but uniformly empty result tree. The rejection is not silent; it produces a structured no-feasible-plan response with the offending dimensions named, so that upstream callers can decide whether to relax the goal, await envelope recovery, or escalate to a different agent.

Prior-Art Distinctions

Classical planners enumerate successors over the full action grammar and rely on the value function to penalize infeasible actions. This approach is sound when the value function is perfect, but it is brittle in the common case where the value function is approximate: high-value infeasible successors leak through. The mechanism disclosed here removes the leak by structural pruning rather than by score penalty.

Reinforcement-learning planners learn an implicit feasibility prior through reward shaping, but the prior is encoded in opaque weights and cannot be reproduced from policy. The disclosed mechanism's filter is declarative: the envelope is canonical, the tolerance is a policy parameter, and the pruning decision is recorded in lineage. An auditor can reconstruct every pruning decision from policy and observed state.

Anytime planners adjust their compute budget on the basis of remaining wall-clock time, not on the basis of demonstrated competence. The disclosed mechanism's competence-scaled budget is a separate axis: a competent agent under tight time pressure plans deeply within the available time; an incompetent agent under generous time pressure does not plan beyond its track record. This decoupling of competence from time is structural.

Disclosure Scope

This disclosure encompasses any predictive planner that interposes a structural capability filter between successor generation and successor scoring, where the filter consumes the canonical capability envelope and prunes successors whose preconditions exceed the envelope on any dimension. The disclosure further encompasses any planner whose compute budget, including horizon, branching, and depth, is a monotonic declarative function of demonstrated competence derived from lineage.

The scope is not limited to any particular planning algorithm, any particular value function, or any particular action grammar. Implementations that prune by structural exclusion rather than by score penalty, and that scale compute by demonstrated competence rather than by wall-clock or by uniform allocation, fall within the scope regardless of the underlying search machinery. Implementations that retain infeasible successors in the scoring frontier, or that scale compute independent of competence, fall outside.