Substrate Resource Negotiation

Mechanism

Resource negotiation is structured as a three-phase bounded protocol between an agent and a substrate scheduler. In the first phase, requirements declaration, the agent emits a structured manifest enumerating the resources it requires for the candidate task: peak and sustained compute, working-memory footprint, network bandwidth class, latency tolerance, actuator reservations where applicable, and the maximum wall-clock duration for which the reservation must hold. The manifest is signed against the agent's capability tier, so the substrate can verify, before any allocation is computed, that the agent is even authorised to request resources of the declared magnitude.

In the second phase, counteroffer, the substrate evaluates current load, queued reservations, and policy ceilings, and returns either an exact match, a constrained counteroffer (reduced bandwidth, deferred start, lower priority class), or a structured rejection with a machine-readable reason code. The counteroffer is not advisory: it is the substrate's binding statement of what it will actually deliver if the agent commits. The agent then either accepts the counteroffer, declines and abandons the task, or declines and retries with a relaxed manifest. Retries are capped; the protocol cannot devolve into an unbounded haggle.

The third phase, commitment, produces an allocation token that names the agent, the capability tier, the declared intent, the granted resource envelope, and the validity window. The token is cryptographically bound to the lineage of the negotiation itself, so any subsequent execution can be traced back to the exact manifest and counteroffer that authorised it. Allocation tokens are revocable: if the substrate's load profile shifts, or if the agent's capability tier is downgraded mid-task, the substrate may issue a graceful preemption notice that triggers the agent's checkpoint-and-yield path rather than a hard kill.

Because every phase emits a structured event into the agent's lineage, the entire negotiation is reconstructible after the fact. There is no oral tradition, no implicit handshake, no scheduler-internal state that would have to be reverse-engineered from logs. The negotiation record itself is the audit artefact.

A subtler structural property is that the manifest is required to be specific. Vague manifests of the form "give me what you can" are rejected at parse time; the agent must commit, before the substrate replies, to a particular envelope. This forces the agent's planning subsystem to develop a model of its own resource needs rather than treating the substrate as an oracle. The structural pressure produced by this requirement propagates upstream: agents that cannot articulate their needs cannot negotiate, and agents that cannot negotiate cannot execute. Capability awareness, in this sense, is enforced not by exhortation but by protocol shape.

The protocol also defines the structural treatment of contention. When two agents simultaneously request overlapping envelopes that the substrate cannot jointly satisfy, the substrate selects between them deterministically using a tier-and-intent ordering that is itself part of policy. The losing agent receives a structured rejection naming the contention as the reason and may retry with a relaxed manifest or defer; it is not left to infer congestion from timing artefacts. This determinism is critical for reproducibility: an agentic system replayed against the same substrate state produces the same allocation outcomes.

Operating Parameters

The protocol exposes a small set of policy-tunable parameters that determine its behaviour in a specific deployment. The maximum round count caps how many counteroffer-and-retry cycles the protocol will tolerate before forcing termination; typical configurations sit between two and four rounds, balancing the agent's interest in finding an acceptable allocation against the substrate's interest in not spending more time negotiating than executing. The capability-tier matrix defines which tiers may request which resource envelopes, and is the structural mechanism by which a deployment expresses that, for example, a tier-three companion agent may not request more than a fixed share of GPU time regardless of how its prompt is phrased.

The intent vocabulary is the controlled set of declared purposes that an agent may attach to a manifest. A deployment that constrains intent to a finite enumeration (diagnostic, generative, retrieval, control, evaluative) gains the ability to apply intent-specific ceilings: a generative intent might be capped at a different latency budget than a control intent, even from the same agent. The reservation horizon governs how far in advance an agent may bind resources, and is the lever by which deployments trade off scheduling efficiency against responsiveness to dynamic load.

Preemption parameters define the grace window between a preemption notice and the substrate's withdrawal of the resource, the checkpoint format the agent must produce, and the priority threshold below which preemption is allowed without explicit consent. Together these parameters allow the same underlying protocol to be tuned for a real-time control domain, where preemption must be exceptional and bounded, or for a best-effort batch domain, where preemption is routine and cheap.

Alternative Embodiments

The same logical protocol admits several deployment topologies. In a co-located embodiment, the agent and substrate scheduler share an address space, and the negotiation collapses into a sequence of in-process function calls; the lineage record is still emitted, but the transport is trivial. In a sidecar embodiment, each agent process is paired with a local broker that mediates the negotiation with a cluster-level scheduler, allowing legacy agent code to participate without modification. In a federated embodiment, multiple substrates pool capacity behind a single negotiation endpoint, and the counteroffer phase includes the identity of the substrate that would actually host the work, which is recorded in the commitment token.

A further embodiment allows the negotiation to be conducted speculatively against a synthetic substrate, producing a counteroffer that is non-binding but accurate; the agent uses it to plan without committing real resources. This is the structural basis for capability-aware planning, in which a planner explores candidate task decompositions by negotiating against a model of the substrate before selecting one to execute against the real substrate.

A delegated embodiment allows a higher-tier agent to negotiate on behalf of a lower-tier agent, with the commitment token naming both the requesting tier and the executing tier. This structurally supports use cases in which a privileged orchestrator obtains resources for an unprivileged worker without elevating the worker's own tier. A pre-committed embodiment allows a deployment to register standing manifests that the substrate honours without per-task negotiation, suitable for high-frequency agentic loops in which the negotiation overhead would otherwise dominate the execution itself; the standing manifest is itself a lineage-recorded artefact and remains revocable.

Composition with Other Capability-Awareness Primitives

Resource negotiation does not operate in isolation. It composes with capability declaration, which provides the tier and envelope against which manifests are validated; with the substrate capability registry, which provides the live picture of what the substrate can offer; and with the lineage subsystem, which persists the negotiation record. The commitment token produced by the negotiation is the input to downstream admission control: the inference-control layer treats the token as the authoritative statement of what resources are available, and refuses to begin execution if no token is present.

Composed in this way, the negotiation protocol becomes the joint between declarative capability policy and runtime resource allocation. A deployment that wishes to change how aggressively agents may request GPU time does not modify the agents; it modifies the capability-tier matrix, and the negotiation protocol enforces the change uniformly.

Prior-Art Distinctions

Conventional resource scheduling in distributed systems treats the scheduler as authoritative and the workload as supplicant: the workload requests, and the scheduler grants or denies, often without a structured reason and without binding the grant to the workload's identity or intent. The protocol described here differs structurally on three points. First, the counteroffer is binding and machine-readable, not advisory; the substrate cannot retract it silently. Second, the commitment token binds the allocation to capability tier and declared intent, so the same compute time requested under a different intent is not interchangeable. Third, the entire negotiation is persisted as lineage, making the allocation auditable independently of the scheduler's internal logs.

Quality-of-service contracts in network and storage systems share the binding character of the commitment token but lack the intent and capability-tier dimensions. Cloud autoscaling systems share the negotiation character but resolve at the level of provisioning, not per-task admission. Neither addresses the cognitive use case in which the requester is itself an agent whose authority to request is a structured property of its declared identity.

Disclosure Scope

The cognition patent discloses resource negotiation as a structural primitive applicable wherever a capability-aware agent must obtain bounded access to a contended resource. The disclosure is not limited to compute and memory: actuator time, sensor bandwidth, communication channels, human-attention budgets, and external API quotas are all expressly contemplated as resources that may be negotiated under the same protocol. The disclosure further contemplates negotiation across organisational boundaries, in which the substrate is operated by a different party than the agent, and the commitment token serves as a contract artefact between them.

The scope extends to embodiments in which the negotiation is conducted by a delegate on the agent's behalf, in which the manifest is generated automatically from a higher-level task description, and in which the commitment token is itself a tradeable artefact that may be transferred between agents subject to capability-tier constraints. Across all of these embodiments, the structural invariants are the same: bounded rounds, binding counteroffer, capability-and-intent-bound commitment, and lineage-persisted record.

The disclosure further contemplates application to multi-agent systems in which a coordinating agent negotiates an envelope on behalf of a team and then sub-allocates to team members, with sub-allocations themselves represented as derivative commitment tokens whose lineage chains back to the parent. Application to long-running tasks is contemplated through renewal protocols in which an agent re-presents its capability tier and intent at configured intervals to extend the validity of an existing token, with each renewal recorded as a distinct event. Application to economically priced substrates is contemplated through manifests that include a cost ceiling and counteroffers that include a cost figure, with the commitment token recording the agreed price as part of the audit trail.