Six-Field Canonical Agent Schema: Structural Definition of Autonomous Semantic Agents

Mechanism

A semantic agent under the canonical schema is a persistent object with exactly six top-level fields. The intent field encodes the declarative goal the agent is being asked to pursue, expressed in a form that is independent of the procedural steps that may be required to achieve it. The context field carries the environmental, relational, and situational data that bound the agent's operation, including identifiers of the invoking principal, the trust zone within which execution is requested, and any temporal constraints. The memory field is a structured reference to the durable state the agent is permitted to read or modify, expressed as a set of typed handles rather than as inlined data, so that the agent's footprint remains bounded regardless of the size of the underlying state. The policy reference field is a cryptographic identifier pointing to the immutable policy bundle that governs which transitions, mutations, and external interactions the agent may attempt; the bundle itself is content-addressed, so the reference cannot be silently redirected. The mutation descriptor field declares, in advance and in structural terms, the categories of state change the agent intends to produce, allowing the substrate to perform admission control before the agent runs rather than after the fact. The lineage field is an append-only record of every prior transition the agent has undergone, cryptographically chained so that any tampering with intermediate states invalidates the chain and is detected on the next evaluation.

Admission proceeds in a fixed order. When a workload is presented to any node of the execution substrate, the node parses the candidate object, verifies that exactly the six required fields are present, verifies that no additional top-level fields exist, and verifies that each field conforms to its declared structural type. Any deviation is grounds for refusal, and refusal is the default; an object is not admitted unless every check passes. Once structural conformance is established, the substrate resolves the policy reference, verifies the cryptographic binding between the policy bundle and the object, and checks that the declared mutation descriptor falls within the envelope the policy permits. Only after all of these checks succeed is the agent scheduled for execution. This ordering is significant: structural validation precedes semantic validation, and semantic validation precedes resource allocation. A non-conforming workload never consumes execution capacity beyond the cost of parsing and rejecting it.

Operating Parameters

The schema is fixed at the platform level rather than at the application level. Individual agents, applications, and tenants do not extend, subclass, or otherwise modify the six-field structure. This constraint is deliberate. If applications were permitted to introduce additional fields, even optional ones, the substrate would lose its ability to make uniform admission decisions, and the portability guarantee would degrade to a portability suggestion contingent on the receiving environment recognizing the extensions. By holding the schema fixed, the platform ensures that any conforming workload is interpretable by any conforming substrate, regardless of whether the substrate has any prior knowledge of the application that produced the workload.

Field-level types are themselves canonical. The intent field is a structured declarative expression drawn from a published vocabulary; free-form natural language is not admitted at this layer because it cannot be evaluated deterministically by the substrate. The context field is a typed record with a fixed set of subfields, each of which has its own canonical type. The memory field is a list of typed handles, each of which resolves to a substrate-managed durable object whose access controls are themselves expressed in canonical form. The policy reference is a content-addressed identifier of fixed length. The mutation descriptor is drawn from a finite enumeration of mutation categories, each of which has a precisely defined operational meaning. The lineage field is a sequence of canonical transition records, each cryptographically bound to its predecessor.

Refusal of non-conforming workloads is uniform and unconditional. There is no privileged caller who may bypass the schema check, no administrative override that admits malformed workloads under exceptional circumstances, and no degraded mode in which the substrate accepts approximations. Every node enforces the same rules, and every refusal is recorded in an auditable log alongside the structural reason for refusal, so that the population of refused workloads is itself analyzable. This property turns schema enforcement from a defensive measure into an observable system characteristic.

Alternative Embodiments

The schema admits multiple serialization forms without compromising its canonical character. A wire form optimized for compact transmission may use a binary encoding with fixed field offsets; a storage form optimized for archival may use a self-describing textual encoding; a debugging form optimized for human inspection may use a verbose representation with annotations. All forms encode exactly the same six fields with exactly the same structural types, and the substrate provides bidirectional, lossless transformation among them. The canonicality of the schema is a property of the object's structure, not of any particular byte sequence.

Embodiments differ in how they bind policy references. In a centralized embodiment, policy bundles may be resolved through a registry operated by the platform provider, with the content-addressing serving primarily as an integrity check. In a federated embodiment, multiple registries may coexist, each responsible for a distinct namespace of policies, with the substrate selecting the registry based on the prefix of the policy identifier. In a fully decentralized embodiment, policy bundles may be distributed through a content-addressed peer-to-peer overlay, with no registry at all; the substrate retrieves bundles by hash and verifies them against the reference embedded in the workload. In every case, the workload object itself is identical; only the resolution mechanism differs.

Embodiments also differ in how lineage is committed. A latency-sensitive embodiment may commit lineage entries to a local append-only log and reconcile with peer logs asynchronously; a consistency-sensitive embodiment may commit lineage entries through a consensus protocol before declaring a transition complete; a forensic embodiment may additionally anchor lineage roots into an external timestamping service at periodic intervals. The choice among these does not change the schema, only the operational characteristics of the lineage field's underlying storage.

Composition

The canonical schema composes with the surrounding execution platform through three well-defined interfaces. The first is the admission interface, through which workloads enter the substrate. This interface accepts only six-field canonical objects and emits either an admission token, which authorizes scheduling, or a structured refusal, which records the reason for rejection. The second is the lineage interface, through which the substrate appends transition records to the agent's lineage field as the agent executes. This interface enforces the append-only property structurally; there is no operation it exposes that can rewrite or remove an existing entry. The third is the migration interface, through which an admitted agent may be moved from one node, region, or substrate implementation to another. Because the agent's complete state is expressed in the canonical schema, migration reduces to transferring the object and re-presenting it for admission at the destination; no translation step is required, and the destination's admission decision is determined entirely by the object's contents and the destination's policy resolution.

Cross-vendor portability is a direct consequence of these interface properties. A workload constructed against one vendor's substrate may be presented to a different vendor's substrate without modification, and provided the second substrate is itself conforming, it will reach the same admission decision and execute the agent under semantically equivalent guarantees. This property holds because the schema is fixed and published, the policy bundles are content-addressed and resolvable independently of any particular registry implementation, and the lineage chain is verifiable by any party that holds the public verification material. No vendor possesses a privileged interpretation of a conforming workload.

Prior-Art Distinction

Prior approaches to workload representation in distributed and agentic systems have generally treated schema as advisory. Container orchestration systems define manifest formats but accept extension fields, vendor-specific annotations, and free-form labels, with the result that a manifest authored for one orchestrator typically requires translation before it can be admitted by another. Workflow engines define task descriptors but allow embedded code blocks whose semantics are opaque to the engine and whose admission cannot be evaluated without executing them. Agent frameworks define message envelopes but treat the contents as application-defined, deferring all structural enforcement to the application layer.

The canonical schema departs from these approaches by treating structural conformance as the entry condition for execution rather than as a downstream concern. It departs further by fixing the field set at the platform level rather than the application level, by content-addressing the policy bundles that govern admission, and by binding lineage cryptographically to the object itself rather than to an external log. None of the prior approaches combines these properties; most combine none of them. The closest comparators in the literature address one or two of these properties in isolation but do not yield the cross-vendor portability that follows from their combination.

Disclosure Scope

The disclosure of the canonical agent schema in US 19/230,933 covers the six-field structural definition, the admission procedure that enforces it, the policy reference mechanism that binds workloads to content-addressed policy bundles, the mutation descriptor that supports pre-execution admission control, and the cryptographically chained lineage field that supports post-execution audit. The disclosure further covers the alternative embodiments described above, including the multiple serialization forms, the centralized, federated, and decentralized policy resolution embodiments, and the latency-sensitive, consistency-sensitive, and forensic lineage commitment embodiments. The disclosure is intended to be read broadly with respect to the specific encodings, registry topologies, and consensus protocols employed, and narrowly with respect to the structural properties that distinguish the schema from prior workload representations: a fixed field set enforced at admission, content-addressed policy binding, and cryptographically chained lineage.

The scope of the disclosure does not extend to particular vocabularies for the intent field, particular type systems for the context field, or particular mutation category enumerations beyond the requirement that such vocabularies, type systems, and enumerations be canonical, published, and uniformly enforced across conforming substrates. Implementers are expected to adopt or publish such vocabularies in a manner consistent with the cross-vendor portability property, and the disclosure anticipates that multiple compatible vocabularies may coexist provided they preserve the structural guarantees described. Where a conforming substrate encounters a workload whose intent expression draws on a vocabulary it does not recognize, the correct response is structural refusal accompanied by a vocabulary identifier, so that the originating party may either retarget the workload to a substrate that recognizes the vocabulary or republish the vocabulary for general use; in no case does the substrate attempt to interpret unfamiliar vocabularies on a best-effort basis, because such attempts would silently undermine the determinism that the canonical schema is constructed to provide.