The signature Field in agent-policy.json: Why It Is null
Published November 14, 2026 · Reviewed November 2026 · By the Ingenious AI team
The short answer
signature is one of the seven required top-level fields in an agent-policy.json file — and in AGENT-POLICY v0.1 its value is always null. It is a placeholder with a roadmap: a future version will define a signature profile so agents can verify a policy's authorship. Today the field exists so that tomorrow's signed policies have somewhere to put the signature, and validators must accept null.
What is the signature field for?
For a problem v0.1 honestly declines to solve: proving the file an agent fetched was really written by the site's owner. Anyone can serve JSON at a well-known path on a domain they control — which is something — but nothing in v0.1 lets an agent cryptographically verify authorship or detect a policy swapped by a compromised server. The spec reserves the field now, as null, so the document shape never has to change when the signature profile arrives; the roadmap names a JWS detached-signature profile as the intended direction. Until then, signature: null reads as "unsigned, by design, for now" — and every published sample carries it.
Why a required field with a fixed value?
Because optional fields that appear later break readers. If v0.1 had omitted signature entirely, every parser written against v0.1 would meet a new field in v0.2 documents and handle it however it happened to handle surprises. By requiring the field from the start — present, typed as string-or-null, and null in practice — the format guarantees that every conforming reader already knows the field exists and where it sits. It is the same discipline as policy_version itself: the versioning machinery described in the versioning guide works because the format reserved its extension points early instead of improvising them later.
What validators and agents do with it today
The validator's rule is one line: signature must be present, and null must be accepted. A missing field is a conformance error — the document lacks one of its seven required fields. A non-null string in a v0.1 document claims a capability the version does not define, and readers should treat the document with the suspicion any undefined claim deserves. Agents, for their part, gain nothing from the field today and should lose nothing by it: authorship assurance in v0.1 rests on the mundane fact that the file was served from the site's own origin over HTTPS at the well-known path. The wider honesty frame — what a valid verdict does and does not certify — is set out in how to validate.
What owners should do: nothing, correctly
Your obligations are exactly two: include the field, and set it to null. Do not invent a signature scheme of your own — a home-made hash in the field is worse than null, because it mimics a verification story no agent can actually check. Do not omit the field to "keep the file clean"; the omission is the one version of this field that makes your document invalid. The free generator emits signature: null automatically, which is the correct amount of attention for the field in v0.1: zero, applied reliably. When a future version defines the profile, the change will arrive as a versioning event, not a surprise.
It is worth being precise about what to tell your own stakeholders when the field comes up, because it does come up — usually in a security review, where a null signature reads, to a hurried eye, like an unfinished control. The accurate sentence is short: the format reserves the field, v0.1 defines no signature profile for anyone to implement, and every conforming policy on the web carries the same null today, including the spec's own samples. Owners who can deliver that sentence, with the roadmap's JWS direction attached, close the question in one exchange. Owners who improvise — who promise signed policies on a version's timetable nobody has published — create the only real risk the field holds: a commitment the format has not made.
Worked example: a hosting company audits 214 policies and finds one signature
Fictional example. Northbeam Hosting, a fictional host serving 214 customer sites that publish agent policies, ran a housekeeping audit with batch validation. The results were boring in the right way: 213 files carried signature: null. One file — hand-edited by a customer who had read about signed policies — carried a base64 string the owner described as "our signature". It verified against nothing, followed no defined profile, and would have meant whatever a reader guessed it meant. The fix took one edit: back to null, with a note to revisit when the format's signature profile actually ships. The audit's real finding was the 213: a reserved field, uniformly null, waiting uniformly for its version.
The signature field checklist
- Include the field.
signatureis required; a missing field makes the document invalid. - Set it to null. In v0.1, null is the only defined value — the unsigned placeholder.
- Invent nothing. No home-made hashes or signature schemes; an unverifiable claim is worse than an honest null.
- Let the generator handle it. Generated files emit the field correctly by default.
- Watch the version. A defined signature profile is future-version work; adopt it when
policy_versionsays so.
Keep reading
Versioning an Agent Policy: policy_version and last_updated · The notice Field: Putting the Honest Scope in the File · Agent Policy vs robots.txt, Compared · Spec samples · Conformance · Pricing · All guides
Frequently asked questions
Why is signature required if it is always null?
So the document shape is stable. Reserving the field in v0.1 means every reader already handles it when a future version defines a signature profile — planned as a JWS detached signature — instead of meeting an unexpected field. Required-and-null is the format buying its future cheaply.
Is a policy with signature null less trustworthy?
It is exactly as trustworthy as v0.1 allows any policy to be: it was served from the site's own origin at the well-known path. v0.1 offers no authorship verification for any policy, signed-looking or not, and the spec lists publisher authentication among its deliberate omissions.
What if I put a string in the signature field?
You have left the defined format. v0.1 defines no signature profile, so no validator or agent can verify your string; readers may treat the undefined claim as a reason for caution. The conforming move is null today and the real profile when its version ships.
Does the validator reject a missing signature?
Yes — absence is an error, because signature is one of the seven required top-level fields. The validator must, however, accept null. Those two rules together are the whole v0.1 contract for the field: always present, presently null.
Will signing change how agents read the rest of the file?
The roadmap's intent is additive: a signature profile would let agents verify authorship of the same document whose verdicts, actions, and terms they already read. Nothing about the planned profile changes what the other fields mean — it attests to who said them.
Generate a policy — free · Validate a policy · What an agent access policy is