The gap

Every agent framework defines an agent implicitly — as whatever the framework instantiates. There is no canonical definition of which fields an agent must carry, what types they must be, or what invariants must hold for an object to count as an agent. Governance is optional metadata, memory is an external service, and lineage goes untracked.

The consequences are structural. Two agents from different frameworks cannot interoperate. No validator can decide whether an agent is well-formed. No governance system can verify compliance by inspecting the object itself. The agent is whatever the runtime says it is — which means it cannot be governed by anything but the runtime.

The invention

The cognition-compatible agent schema defines a canonical object whose fields are the agent. Intent, context, memory, a policy reference, a mutation descriptor, and lineage are typed, validated fields — present and well-formed, or the object is simply not an agent. Governance, memory, and lineage are intrinsic to the object rather than bolted on around it.

Two properties follow from that construction. Validation happens at rest: a governor can inspect an agent object, verify its fields, walk its lineage chain, and determine its execution eligibility without ever running it. And partial agents — objects carrying some but not all fields — are first-class, admitted under structurally restricted roles instead of being rejected, so an agent can be assembled, delegated, and completed across systems.

The inventive step

The departure from prior art is where authority lives. In existing frameworks, governance is applied to an agent from the outside; here, governance is the condition of agenthood — an object is an agent only because it carries valid governance, memory, lineage, and eligibility fields. Agenthood is defined by structure, not by instantiation.

That inversion is what makes the rest possible: validation before execution, interoperability across heterogeneous runtimes against a common object, and deterministic handling of partial or in-progress agents. None of these follows from treating an agent as a framework instance; each follows directly from treating its fields as constitutive.

Alone, and in composition

On its own, the schema is a vendor-neutral object contract — a way to serialize, validate, and exchange task objects across heterogeneous systems and robotics fleets that otherwise share no agent definition.

In composition, it is the atom every other layer operates on. Inference control gates transitions on agent state; confidence governance reads agent fields to judge execution readiness; cryptographic governance signs and verifies agent policy. Without a canonical object, none of them can act on a common substrate. The schema is the interoperability layer the rest of the architecture stands on.