Skip to content

[RFC] Agent Manifest: a signed, pre-execution declaration layer for agentic systems #149

Closed as not planned

Description

@imran-siddique

Authors / initial contributors:

  • @imran-siddique - Imran Siddique, Chief Platform Officer, Opaque Systems; creator, agentrust-io

Endorsing organizations:

  • Opaque Systems
  • TII (Technology Innovation Institute), founding partner
  • Intel
  • AMD
  • NVIDIA (in progress)

Co-editor seats open; see "The ask" below.

Status: Phase 2. Phase 1 feedback collection closed August 9, 2026; the review record was posted August 12 and the Phase 2 record on August 18. Phase 2 is the readiness pass ahead of a submission decision, and the ask below is now live for the approvers rather than deferred.

Related WS4 work: #99 Agent Credentials · CoSAI Agentic Identity & Access Management paper (May 2026) · presented as item 3 in the July 23 WS4 meeting


Summary

Agent Manifest is a single signed record that binds every deployment artifact an agent carries, published at a known location and readable by any relying party before the agent acts. It is a pre-execution declaration, not a runtime monitor or an after-the-fact log.

WS4's Agentic Identity & Access Management paper establishes verifiable identity, continuous verification, and traceable authority for agents. #99 Agent Credentials specifies the claims an agent presents so a gateway or peer can make an access decision. Agent Manifest is complementary to both: it is the bound, hardware-sealed content those claims refer to, the concrete declaration layer that sits in front of the identity and protocol layers WS4 has already defined.

Phase 1 review is complete. Phase 2 asks WS4 to judge the revised specification, reference implementation, and public disposition record before deciding whether to bring Agent Manifest into CoSAI.

The gap this fills

Identity and delegation are well specified on paper. What is not yet standardized is a single, signed, pre-execution artifact that a relying party can check before the interaction starts, distinct from a runtime log produced after the fact. Agent Credentials answers "who is this agent and what may it access." Agent Manifest answers "what exactly is this agent made of, sealed to hardware, before it does anything."

What Agent Manifest is

One signed record binding ten deployment artifacts:

  1. System prompt
  2. Policy bundle
  3. Model identity
  4. Tool schemas
  5. RAG corpus
  6. Memory baseline
  7. Decision trace
  8. A2A delegation chain
  9. Build provenance
  10. HITL approvals

The record is anchored to hardware attestation so a swapped container, model, or policy invalidates it. Attestation status today (verifiable in-repo, not aspirational):

  • AMD SEV-SNP - hardware-validated on bare metal (GCP N2D)
  • Intel TDX - DCAP quote verification, hardware-validated (GCP C3)
  • TPM 2.0 - shared quote verifier implemented
  • Opaque Managed Runtime - not yet implemented; on the roadmap
  • Azure TDX via MAA - deferred (offline-attestation limitation documented)

We would rather list this precisely than overstate it. "Proof, not promises" only means something if the proof column is honest.

Why bring it now, not later

  • Open and public. Spec and the reference SDK (Python) are live under github.com/agentrust-io; docs at manifest.agentrust-io.com. Apache-2.0 licensed, open-core. Latest SDK release python-v0.11.0 (2026-08-11). A TypeScript SDK is on the roadmap and not started; the conformance vectors are the portable contract any second implementation would be written against.
  • Security-hardened. Repos carry OpenSSF Scorecard, CodeQL, Dependabot, pip-audit, and bandit on every PR.
  • Regulator-mapped. Four conformance levels mapped to EU AI Act high-risk obligations (binding August 2, 2026).
  • Repo now names CoSAI, not another body. The project's declared standards target was AAIF; as of today the spec header, CHARTER, GOVERNANCE and roadmap name CoSAI WS4 as the v1.0 path (agent-manifest#253). The two remaining AAIF references describe MCP's own governance home, not this spec's target. IP terms are recorded as consequences of the OASIS Open Projects IPR Policy rather than as commitments, pending counsel review.
  • Coalition intent. TII is a confirmed founding partner. Intel and AMD have joined as endorsing organizations; NVIDIA is in progress. Co-editor seats are open (Anthropic, OpenAI, Google, Microsoft, Block, ServiceNow invited). This is meant to be shaped by WS4 before v1.0, not handed over finished.

Alignment with WS4 outputs

WS4 output What it governs What Agent Manifest adds
Principles for Secure-by-Design Agentic Systems Intent, the design values A concrete artifact that instantiates those principles per agent
MCP Security whitepaper Protocol-layer threats (identity misuse, context tampering, supply chain) Binds build provenance + SBOM, so a swapped container invalidates the record
Agentic Identity & Access Management Credential issuance, delegation, continuous verification A signed, pre-execution declaration the identity layer can check against

Alignment with the agent development lifecycle

The ten artifacts are not arbitrary; each is produced by a real ADLC phase and carried forward as evidence.

  • Design - system prompt, policy bundle
  • Build - model identity, tool schemas, build provenance
  • Deploy - A2A delegation chain, HITL approvals
  • Monitor - decision trace, RAG corpus, memory baseline

This maps onto the ADLC SIG scope.

Why a separate artifact, and not just a JWT or credential extension?

This came up in the July 23 discussion, and it is the right question. A JWT-packaged credential asserts identity and claims for an access decision at request time. Agent Manifest is the bound, hardware-sealed set of deployment artifacts that such a claim can point to or attest over. The two are layered, not competing:

  • A credential can carry a manifest digest as one of its claims; the manifest is what makes that claim checkable against the actual deployed agent.
  • The manifest is pre-execution and content-bound (system prompt, policy, model, tools, provenance), where a credential is identity- and access-bound.
  • Keeping the declaration separate lets the same manifest be referenced by different credential formats (W3C VC, JWT, X.509/SPIFFE) rather than being locked to one.

In short: Agent Manifest does not replace Agent Credentials or JWT-based claims. It gives them something concrete and hardware-anchored to refer to. We would like to work this boundary out with the #99 authors directly.

What we learned in Phase 1

Phase 1 did not prove that ten fields are the final schema. It helped clarify the boundary.

Manifest, credentials, and Agent Card

The original problem was simple: what changed, and can a relying party verify it before the agent acts?

  • Manifest: the signed deployment record for behavior, model, tools, context, provenance, and approvals.
  • Credential: identity, authority, access, and current status.
  • Agent Card or registration record: discovery and agent metadata.

My current view is to cross-reference these, not merge them yet. A credential or Agent Card can carry a manifest URI, digest, and type. The manifest can reference its issuer identity. None replaces the others.

Phase 2 should first compare Agent Manifest with Agent Card and the Agent Registration Record, field by field. That will tell us whether we need a separate schema, an extension, or a profile.

Reuse what already works

We should not create another BOM, provenance format, signature envelope, or attestation format. The manifest should reference SPDX or CycloneDX, SLSA, COSE, and platform evidence where they already do the job.

The missing piece is the binding across agent behavior, model, tools, context, delegation, and approvals. If an existing standard expresses a field and a verifier can check it, we should reuse it.

Where is the agent boundary?

Layer What is bound
Agent composition Prompt, policy, model, tools, context, memory, delegation, approvals
Execution workload Container or runtime measurement bound to the manifest digest
Mediation plane Gateway or proxy configuration, separately attested and cross-referenced
External services Stable identifiers, declared dependencies, and freshness limits

Ian asked why we do not attest the whole workload. I think we should. But that does not close the problem by itself.

A workload measurement does not describe a provider-hosted model, a changed system prompt, an independently versioned MCP server, or a RAG corpus. Component hashes have the opposite gap: they describe the expected set but do not prove that set is running. We need both.

If a gateway or proxy can change behavior or authority, it is part of the governance boundary. It needs its own attested record and cross-reference, or it must be declared as an external dependency.

Who verifies it?

User Action
Admission controller Verify the record and admit, restrict, or block
MCP/A2A gateway or peer Resolve the manifest reference before accepting the interaction
Operator or security team Investigate drift, acknowledge it, and re-verify
Auditor or incident responder Compare declared state with runtime evidence and logs

For example, I want manifests for my Claude and Codex agents. If a provider changes the model or system prompt, I want a drift notification and an explicit decision. The manifest cannot stop the provider change. It can stop us from silently treating the deployment as unchanged.

What this does and does not cover

The manifest targets artifact substitution, unapproved drift, rollback, omitted dependencies, and identity-to-content mismatch.

It does not by itself stop malicious but declared behavior, runtime prompt injection, abuse through valid authority, an unmeasured gateway, or drift after admission. Those need runtime policy, telemetry, and re-attestation. The manifest gives those systems a baseline to compare against.

The Phase 2 ask

Phase 2 should be short. The goal is to resolve the overlap, not start another long review.

  1. Confirm that the signed pre-execution deployment record fills a WS4 gap.
  2. Ask the Agent Credentials workstream to co-edit the manifest boundary. Ben explicitly offered this collaboration.
  3. Produce a short crosswalk covering Agent Credentials, Agent Card, the Agent Registration Record, and existing BOM formats.
  4. Decide whether Agent Manifest comes into CoSAI or remains an external reference.

If we can close those four items quickly, I think this is ready for a decision.

Phase 1: what was asked for, and the window that closed (August 9, 2026)

A thorough, critical review pass. Please be as hard on this as possible. Everything below is a filable unit of work with a named destination, so nobody has to guess where a comment should go.

How to file

  • Spec questions and normative changes: agentrust-io/agent-manifest → New issue → Spec change template.
  • Implementation and crypto bugs: same repo → Bug report template.
  • Anything already open: comment on the existing issue rather than opening a new one; the list is below.

Every WS4-originated issue gets the cosai-ws4 label so the review pass is auditable in one query, and triage within two business days. Nothing gets silently closed: if we disagree, we say so in the thread and record why.

Nine review tracks

Each row is a question we want attacked, the section that answers it today, and what a useful issue looks like. Spec: spec/agent-manifest-spec-v0.1.md.

# Question to attack Read A good issue looks like
1 Are the ten artifacts the right ten? What is missing, what should be dropped? §1.3, §3.2 "Artifact N is underspecified because X" or "the set is missing Y, here is the attack it enables"
2 Is the hardware binding sound? SEV-SNP and TDX validation is reproducible; break it. §3.3 A concrete substitution attack that still verifies
3 Signature envelope: we are migrating to COSE_Sign1. Right call, right profile? §3.6, §4.1, #243 Profile objections, algorithm choices, interop consequences
4 Revocation and key rotation: is the model workable at scale? §3.7, §3.8 Failure modes, freshness gaps, operational objections
5 Verification semantics: what does a relying party do on partial verification? §5.3, §5.4 Ambiguity in the result schema, cases with no defined answer
6 Conformance levels: are the four levels drawn in the right places? §8.1, §8.2 "Level N is not testable" or "the line between N and N+1 is meaningless"
7 Out-of-scope list: is anything excluded that cannot honestly be excluded? §7.2, LIMITATIONS.md Something excluded that a relying party would reasonably assume is covered
8 EU AI Act mapping: high-risk obligations went binding August 2. Is the mapping defensible? §9.1 to §9.4 An article mapped too generously, or an obligation with no artifact behind it
9 Boundary with Agent Credentials (#99) and the Identity paper §6.2, §6.3, §10.4 See the joint document below

Open issues that already need adversarial eyes

These are our own known gaps, filed publicly. Piling on beats opening duplicates.

  • agent-manifest: #243 COSE_Sign1 envelope migration · #236 Azure TDX via MAA, deferred with the offline-attestation limitation documented · #204 verify attestation chain and TRACE claim signature in the SDK
  • trace-spec: #66 two-axis verification model · #50 build_provenance verification depth · #76 revocation and transparency at verify time · #67 key revocation claim
  • cmcp, the enforcement side, where our sharpest gaps are: #370 verify attestation report signatures · #371 make cnf.jwk to report_data binding fatal · #432 gateway is not measured into a PCR, so the policy tamper claim is unenforced · #433 no TCG event log, so PCR digests are uninterpretable
  • ca2a: #18 A2A v1.x profile stability, directly relevant to the delegation chain in §3.4

If the answer to "what would have to be true for this to be worth accepting into CoSAI" is one of those four cmcp items, say so on the issue and we will treat it as a gate rather than a backlog entry.

The #99 boundary, as a joint document

Rather than argue the line in comment threads, I propose one co-authored file at docs/integrations/agent-credentials.md in agent-manifest: what a credential asserts, what a manifest binds, the digest-as-claim pattern, and an explicit list of what neither one covers. I will open the PR with a first draft and the skeleton of the "neither" list. @imolloy and the #99 authors, if you would rather own the draft, the PR is yours and I will review.

Reciprocity, and what happens on August 9

Reviewing goes both ways. If you have a spec, threat model, or schema you want the same treatment on, point me at it and Opaque contributors will file against it on your terms.

On August 9 I will post one comment here with every cosai-ws4 issue, its disposition, and what changed in the spec as a result. Anything we decline, we decline in writing with a reason. That is the record I would want WS4 to judge before anyone votes on accepting this.

We will triage and address the feedback over this window and bring back a revised, hardened version before proposing any repo creation or contribution. We are keeping this on GitHub deliberately, consistent with the WS4 GitHub-first norm.

Contributor mechanics are in CONTRIBUTING.md; governance and the antitrust posture are in GOVERNANCE.md and ANTITRUST.md. Work tagged fellowship is scoped for anyone who wants to go deeper than a review pass.

References


Reviewers, your critical read would be very welcome: @sarahnovotny @imolloy @benhylau @rithikha @ksingh299 @claurau. Happy to bring in additional contributors to help work through anything raised here.

Activity

  1. AgentGymLeader commented on Jul 27, 2026

    @AgentGymLeader

    Supportive of separating a pre-execution declaration from runtime evidence and from any after-the-fact judgement. That separation makes it legible, per artifact, what is being asserted and what is not.

    I especially value that the docs state plainly that boot-time validation does not monitor subsequent runtime drift. A spec that narrows its own scope in writing is easier to build on.

    "Pre-execution declaration layer" also reads as an accurate name for what this artifact does.

  2. rabbidave commented on Jul 31, 2026

    @rabbidave
    Contributor

    @imran-siddique @AgentGymLeader re the boot-time/runtime split you're both anchoring on is exactly the seam we're targeting with the stateful-fingerprint bridge into OCSF/OTel.

    The Manifest stays a pre-execution declaration (unchanged scope); the fingerprint carries ai_agent.instance_uid/version/charter forward as the runtime-evidence trail, so drift gets judged against the declared identity without pulling drift-detection into this RFC's boot-time contract.

    This is also the mechanism that would answer #151's per-sub-bundle escalation question and close the T12 audit-log gap from ws4-secure-design#89

    e.g. by having a portable kv-cache-as-identity

    i.e. same evidence layer, three consumers. Worth a pointer from s3.2.2/§8 to this as the intended runtime-evidence hook, or kept separate deliberately?

  3. imran-siddique commented on Jul 31, 2026

    @imran-siddique
    Author

    @imran-siddique @AgentGymLeader re the boot-time/runtime split you're both anchoring on is exactly the seam we're targeting with the stateful-fingerprint bridge into OCSF/OTel.

    The Manifest stays a pre-execution declaration (unchanged scope); the fingerprint carries ai_agent.instance_uid/version/charter forward as the runtime-evidence trail, so drift gets judged against the declared identity without pulling drift-detection into this RFC's boot-time contract.

    This is also the mechanism that would answer #151's per-sub-bundle escalation question and close the T12 audit-log gap from ws4-secure-design#89

    e.g. by having a portable kv-cache-as-identity

    i.e. same evidence layer, three consumers. Worth a pointer from s3.2.2/§8 to this as the intended runtime-evidence hook, or kept separate deliberately?

    Thank you, can you start an issue or PR on the repo to see how it would look like?

  4. imran-siddique commented on Jul 31, 2026

    @imran-siddique
    Author

    I have moved the Phase 1 ask into the issue body rather than leaving it in a comment, so there is one canonical place to work from. It now carries nine named review tracks (each with the section to read and what a useful issue looks like), the list of our own open issues that need adversarial eyes, filing mechanics, and what I will publish on August 9. Two commitments worth stating plainly: every WS4-originated issue gets the cosai-ws4 label and a triage response within two business days, and anything we decline, we decline in writing with a reason.

    One change on our side that belongs in this thread. The project's declared standards target was AAIF, which contradicted this RFC. The spec header, CHARTER, GOVERNANCE, ROADMAP and section 10.3 now name CoSAI WS4: agent-manifest#253. Three notes on that PR, because a find-and-replace would have been wrong:

    • The two remaining AAIF references are deliberate. Both describe MCP's own governance home, not this spec's target.
    • The conformance suite is decoupled from the AGT donation, since AGT's destination is governed separately.
    • IP terms are recorded as consequences, not commitments. The OASIS Open Projects IPR Policy requires a CLA and a patent non-assert on non-trivial contributions, which is stricter than the DCO-only regime we run today. CHARTER section 4 states it takes effect only on WS4 acceptance, and that my own terms under it need counsel sign-off before anything is filed. I would rather have that in writing now than discover it at submission.

    @rabbidave, on the runtime-evidence hook: two separable pieces, and I would keep them apart.

    1. Non-normative pointer, an issue against §7.2 and §8: one paragraph saying the manifest declares pre-execution state and does not monitor drift, and that runtime evidence consumers may carry the manifest digest forward as a correlation key. Additive, does not touch the boot-time contract.
    2. The correlation key itself, a spec_change issue against §3.1 and §5.2 for whatever field the OCSF/OTel bridge keys on (instance_uid, version, charter). This touches the normative schema, so it needs its own thread and its own objections.

    Open (1) with the paragraph you would want to read and I will review it this week. For (2) a PR against the §3.1 schema with one worked example beats prose. I am deliberately not taking a position yet on whether the pointer should be normative; that is what the issue is for.

    @imolloy and the #99 authors: rather than argue the boundary across three threads, I propose one co-authored file at docs/integrations/agent-credentials.md covering what a credential asserts, what a manifest binds, the digest-as-claim pattern, and an explicit list of what neither covers. I will open the PR with a first draft, or it is yours if you would rather own it and have me review.

    Reviewing goes both ways. If you have a spec, threat model, or schema you want the same treatment on, point me at it and Opaque contributors will file against it on your terms.

  5. litzki-systems commented on Aug 7, 2026

    @litzki-systems

    Review comment – issuer trust-anchor resolution (after #215 / #220)

    Scope: remaining specification gap for how a relying party learns which key is authorized for the declared issuer.

    Summary

    PR #220 closed Issue #215 at the SDK level. verify_manifest now resolves the signing key and checks that the key is authorized for the declared issuer before signature verification begins. The specification still leaves the source of that authorization undefined. Every verifier builds its authorization state from local configuration. The reference CLI shows the same boundary: manifest verify takes the public key as a parameter.

    Section 3.6 places key_id outside the signing pre-image. The field identifies a key. It does not authorize one. Authority enters the verification process through a step the specification never defines. This decides what a CoSAI conformance claim means to a third party. It sits primarily under review tracks 4 and 5.

    Specific points

    1. key_id carries no integrity today.
    The signature object sits outside the signing pre-image by the table in 3.6. signature.key_id is unauthenticated metadata. A key authorization model needs a binding that survives that.

    2. Two prohibitions are worth stating normatively.

    1. A verifier accepts only a key resolved through the authorization path. Consequently, a key carried inside the document stays unusable.
    2. A verifier rejects issuer authorization derived from an identifier controlled by the attested subject. Otherwise issuer and subject collapse into one role on every self-issued manifest.

    3. The existing transparency log already provides a suitable place for key-to-issuer bindings.
    The spec requires a transparency log entry for production. A key-to-issuer binding recorded in the same log gives discovery, rotation and revocation through one mechanism the spec already mandates. Section 3.8 traverses rotation chains, so the shape is there.

    4. Extend the existing pattern for weak bindings.
    The spec already marks weaker claims explicitly (PROVIDER_ASSERTED, UNVERIFIABLE). The verification result reports no signal about which trust path authorized the issuer key. hitl_record.approvals is normalized to an empty array before signing. Approvals therefore travel a separate trust path while the result returns a plain APPROVED.

    5. Make it testable.
    The suite reports 197 conformance tests. Negative vectors let the suite fail an implementation that accepts an unauthorized key:

    • a key taken from the document
    • a key published under the subject’s label
    • a valid signature from a key unauthorized for the declared issuer
    • a rotation chain with a gap

    Offer

    I maintain a published attestation format that resolves the issuer key from an anchor separate from the subject’s identity label. The two prohibitions above are stated normatively in that format. Independent third parties have verified the complete path with third-party tooling. The verification included a probe that issuer and subject roles separate cryptographically rather than by name.

    I can contribute the negative vectors and a draft of the normative text. I can also file the corresponding issues in agentrust-io/agent-manifest under the Spec change template.

  6. rabbidave commented on Aug 11, 2026

    @rabbidave
    Contributor

    @litzki-systems on issuer trust-anchor resolution, there may be less to draft
    than it looks. OCSF has an attestation object on main whose authority_uid exists
    for exactly your point 1: a verifier uses it to confirm that a signing credential
    belongs to the expected authority rather than to a different holder of some
    otherwise-valid credential. Chain membership and ordering come from chain_uid and
    prev_event in the same object, under the record_integrity profile.

    That does not close your point 2. Nothing there prevents issuer authorization
    being derived from an identifier the attested subject controls, and stating that
    prohibition normatively is still worth doing.

    Where I would push on the binding: deriving the session identifier from the RFC
    9266 tls-exporter value for the connection in use, or tls-unique per RFC 5929
    below TLS 1.3, makes it unforgeable across channels and non-replayable onto a
    different one. The active trust anchor set and an as-of timestamp then travel as
    recorded evidence rather than as the binding value, so an anchor rotation shows up
    as a delta between emissions instead of an assumption that a long-lived pinned
    root has not been substituted. Two honest caveats: where TLS terminates ahead of
    the agent process the exporter value is only available from the terminator, which
    makes the terminator part of the attested trust base, and none of this helps
    against a fully compromised endpoint that can misreport any value.

    Related inventory proposal upstream at ocsf/ocsf-schema#1724, which uses record_integrity
    rather than inventing chaining.

    On the sponsor question: I am planning to sponsor normative text on PayPal's
    behalf pending exec and legal sign-off. If you are in a similar position, your
    offer to draft the two prohibitions may clear the rule in
    agentrust-io/agent-manifest on its own.

  7. imran-siddique commented on Aug 12, 2026

    @imran-siddique
    Author

    Phase 1 review record — posted August 12, 2026

    I committed to post this on August 9. I missed that date by three days. That is on me; the delay does not change the disposition of any feedback below.

    This comment records the GitHub review work received during the Phase 1 window and imports the substantive third-party feedback from the LinkedIn review thread. LinkedIn comments are paraphrased here with attribution so the standards discussion has a durable public record in the RFC's actual home.

    GitHub feedback and disposition

    Item Feedback Disposition
    agent-manifest#267 Define the Agent Credentials/Manifest bridge around signed state at a defined stop boundary. Accepted for design work. The integration document remains open. It must distinguish a pre-execution declaration from state captured at tool-use/session-stop and state that cannot be honestly reconstructed mid-execution.
    agent-manifest#268 Say explicitly that the manifest does not monitor runtime drift, and point non-normatively to correlated runtime evidence. Accepted. This belongs in §7.2/§8 without changing the manifest schema or pretending the manifest is a runtime monitor.
    agent-manifest#269 / PR #270 Define the correlation key joining the manifest to OCSF runtime evidence. Direction accepted; normative details still under review. The join must be explicit and testable. The remaining concern is the overload between a stable agent identity and OCSF's session-scoped instance_uid; the spec must not silently treat those as identical concepts if their lifetimes differ.
    agent-manifest#243 COSE envelope and verifier security findings raised during the same review period. Implementation findings addressed; conformance follow-up remains. Key-to-issuer authorization, ambiguous JSON, version/envelope mismatch, dependency handling, and bounded nesting shipped through #274, #278, and #290. The remaining work is cross-language negative-vector coverage.

    One project-level correction also shipped during the window: PR #253 changed the declared standards target from AAIF to CoSAI WS4 while keeping the IPR consequences conditional on acceptance and counsel review.

    LinkedIn feedback imported into this RFC

    The comments converged on one result: the pre-execution manifest is useful, but it must not absorb runtime or point-of-commitment claims merely because all three can be signed.

    • Hiresh Verma supported attestation-backed manifests but stressed that a deploy-time snapshot does not show what an agent actually read or sent to a tool. Disposition: agree. Live data flow belongs to runtime enforcement/evidence, not to the manifest's pre-execution claim.

    • Jeff Narucki noted that identity alone is below the minimum needed to understand an agent's risk profile or incident impact. Disposition: agree. The manifest adds configuration evidence, but neither identity nor configuration alone establishes runtime impact.

    • Frank Sellhausen drew the line as manifest = what was running and credential = who authorized it, then asked whether the manifest active at the decision under review can be produced. Disposition: adopt with one refinement. Authorization is one credential function, while the manifest binds approved deployment content. Historical retrieval of the manifest that governed a particular action is a real audit requirement; the runtime record must carry a verifiable reference to that exact manifest, not merely the latest one.

    • Aditi Singh supported the work as an important open, verifiable trust layer and emphasized continued community review and implementation. Disposition: support recorded. The implementation and conformance evidence remain public and reviewable rather than being treated as proof by assertion.

    • Jim Rosenberger argued that nine artifacts describe what the system is while the decision trace describes what it did; signing an execution-produced account proves integrity, not completeness or faithfulness. He placed the critical audit boundary at evidence produced at commitment versus evidence produced afterward. Disposition: agree with the assurance distinction. “Decision trace” cannot inherit pre-execution assurance merely by appearing in the same signed structure. Its role in the ten-artifact set needs to be narrowed to a predeclared trace policy/schema or moved to a separately linked runtime record.

    • Hlias Staurou made the same artifact-level objection directly: the decision trace is produced by execution and should be linked rather than embedded as though it existed before the agent moved. He then identified the essential follow-up: cryptographically join manifest-at-T0 to trace-at-T1 for the same agent instance without trusting the operator's linkage. Disposition: accepted. docs(containment): resolve the §4 and §1.1 drafting residue (#172) #268 captures the boundary; docs(containment): add clause C7 on coverage gap naming (#172) #269/docs(containment): add conformance cases for the independence test (#172) #270 carry the join-key work. The join must bind the exact manifest digest and the runtime instance/session under authenticated evidence.

    • MRT T supported the accountability value and asked how the manifest can evolve with AI technology without weakening compliance rigor. Disposition: valid design constraint. Evolution must occur through versioned schemas/profiles, explicit algorithm identifiers, bounded compatibility rules, and conformance vectors—not through open-ended fields that different verifiers interpret differently.

    • Raghu Yeluri supported the Manifest/TRACE separation: the manifest is supplied to a verifier; TRACE is the immutable, auditable verification/runtime record. Disposition: agreed as the target layering, with the caveat that TRACE evidence must identify the exact manifest and instance it evaluates.

    • Harry Martin supported the open-source approach and continued progress. Disposition: support recorded. Public spec, SDK, tests, and hardware-validation artifacts remain the basis on which the work should be judged.

    What changes as a result

    The Phase 1 result is not “the ten artifacts were confirmed as written.” It is a sharper three-layer model:

    1. Credential: who/what is presenting a claim and under what authority.
    2. Manifest: the versioned, signed pre-execution declaration of the deployment content approved to run.
    3. Runtime/commitment evidence (including TRACE): what was observed, evaluated, or committed during execution, cryptographically joined to the exact manifest and agent instance.

    That means the current treatment of decision trace requires correction. A pre-execution manifest may bind the policy, schema, destination, or commitment mechanism for future traces. It cannot contain a trace that does not yet exist or imply that a self-produced trace is complete and faithful. The runtime trace should be a separately signed/attested record linked back to the manifest.

    Remaining Phase 1 actions

    Thank you to everyone who challenged the boundary rather than merely endorsing the premise. The strongest outcome of this review is the correction: a signature preserves a record; it does not, by itself, prove that a runtime account is complete, faithful, or tied to the action under review.

  8. litzki-systems commented on Aug 15, 2026

    @litzki-systems

    @rabbidave Agreed on the split. authority_uid under record_integrity covers the verification side of point 1, so the normative work narrows to point 2: issuer authorization must not derive from an identifier the attested subject controls. That is the requirement PR #220 enforces in the SDK but the specification leaves to deployment.

    The TLS-channel-binding path deserves one caveat beyond the two you named. Where TLS terminates ahead of the agent process, the terminator enters the attested trust base. That is a scope change worth stating explicitly rather than treating as a deployment detail, because it moves the trust boundary and changes what the attestation actually covers.

    On authoring the prohibition language: #271 established who may author normative text, and the Phase 1 review record scopes the remaining actions. I want any contribution here to follow that process. Happy to comment on specifics as they develop.

  9. imran-siddique commented on Aug 18, 2026

    @imran-siddique
    Author

    Phase 2: the review changed the spec, and here is what changed

    Phase 1 asked WS4 to be as hard on this as possible. It was, and the result is not "the ten artifacts were confirmed as written." Six reviewers filed spec changes that found real defects, three of them in the parts of the design this RFC leaned on hardest. Every one has either landed on main or is an open pull request with CI green and maintainer review outstanding, marked below either way, and the label is queryable: cosai-ws4 in agent-manifest covers 9 issues and 18 pull requests, with the review targets in cmcp, trace-spec and ca2a carrying the same label.

    I said in Phase 1 that anything declined would be declined in writing. Nothing was declined. One proposal was accepted in substance rather than literally; the other was accepted in full. Those are the two worth reading.

    What the review corrected

    Filed by The defect What landed
    @contrario (#273) audit_chain_root is fixed at signing time and decisions happen after. A verifier could confirm the chain still contained the signed root and could not tell an append-only extension from a chain rebuilt around that prefix. entry_count constrains nothing above the signed count. §3.2.7.1: RFC 9162 consistency proofs for merkle-log, a forward fold of appended entry leaves for hash-chained, the same fail-closed stages memory already had. decision_trace gains EXTENDED for a proven extension; an unproven divergence is still MISMATCH.
    @sapsan14 (#265) §2.2's artifact-only refresh contradicted §3.3. manifest_hash_in_report covers the signature block, so re-signing alone breaks the binding and the retained attestation binds the previous document. The refresh path is withdrawn at Level 1+. And the larger half: the verifier only reported a mismatched attestation hash when enforce_attestation was set, so the default path returned VALID for exactly this case. Present-and-wrong is now MISMATCH either way. AM-VEC-021 pins it.
    @sapsan14 (#266) No relying-party challenge. verification_id and verified_at are both producer-chosen, so a signed VALID was replayable to another party, for another purpose, or against a weaker context. §5.1.2: challenge_nonce, verification_context_hash, and the rule that a producer timestamp alone does not satisfy freshness. derive_runtime_nonce() composes this challenge with the §3.3.2 runtime report so the two freshness domains cannot be replayed independently. Open for review: PR #314.
    @Mayur021 (#272) §5.3 defined behaviour on MISMATCH and none on VALID, and the overview claimed the manifest proves "what it was allowed to do". §5.3.2: VALID is provenance, not permission. Per-call authorization joins the §7.2 out-of-scope list, and the overview sentence is narrowed to what the model actually binds. The conformance test came first, written by the reporter.
    @rabbidave (#268, #267) The manifest does not monitor runtime drift, and the #99 boundary needed a document rather than three comment threads. Both closed: the runtime-evidence boundary in §7.2/§8, and docs/integrations/agent-credentials.md.
    @nikshilov (#298) A governed memory checkpoint establishes integrity, ordering, freshness and budget, and establishes nothing about retrieval behaviour. Every failure mode listed passes all four checks with no forged signature. §3.2.6.2 says so as of PR #316, open for review. The assessment harness is external non-normative work and #298 stays open as its tracking issue; the boundary is written down first so the spec does not claim an assessment that does not exist.

    Two proposals, two dispositions

    @rabbidave asked that OCSF ai_agent.instance_uid equal the manifest agent_id (#269). Taken literally that makes OCSF's two identity fields identical for every deployment following §3.1's stated path convention, and a consumer then cannot separate "every run of this agent" from "this run", nor tell that the collapse happened. What the proposal was right about is that a join key was missing and that instance_uid is where it belongs. PR #310, open for review, defines agent_id as the stable identity and adds a signed agent_instance_id for instance scope, makes §6.4.2 normative, and forbids falling back to agent_id for instance_uid in rule 3. Emitting no instance_uid is a better failure than emitting a stable one.

    @Mayur021 asked for one sentence in §5.3 and one bullet in §7.2. Both landed, plus a correction to the overview paragraph, because that sentence is where the misreading starts.

    The cmcp gates

    Phase 1 said that if a reviewer named one of four cmcp items as the condition for accepting this into CoSAI, it would be treated as a gate rather than a backlog entry. All four are closed.

    • #432, #433 — the gateway is measured into a TPM NV index and a TCG event log is collected, so the policy-tamper claim is enforced and PCR digests are interpretable.
    • #370 — all three report-signature paths implemented and validated against genuine hardware: SEV-SNP VCEK chain (Azure CVM), Intel TDX DCAP quote and PCK chain (GCP C3), TPM TPMT_SIGNATURE and AK chain (Azure vTPM). Runs recorded in docs/testing/hardware-validation.md.
    • #371 — and this one is the reason I would rather you read the diff than the summary. TDX read both of the fields it attests from the wrong offsets. REPORTDATA at 0x08, inside REPORTMACSTRUCT's leading RESERVED block, with a mismatch left advisory. MRTD at 0x90, inside REPORTMACSTRUCT.report_data — the 64 bytes the guest itself supplies. The producer wrote its nonce there and hashed 48 bytes of it back out as the TD measurement, so two attestations of the same TD with different nonces produced different measurements. Producer and verifier each carried their own copy of the offsets, both wrong the same way, so every round-trip test passed. One ctypes definition now serves both, with the ABI offsets asserted at import. Separately, TDX had no equivalent of the SNP rule that an unverified chain cannot be reported as hardware-backed; it does now.

    That defect was in the repository this RFC pointed at as its enforcement side, in the platform this RFC listed as hardware-validated. It is fixed and merged, the fix is asserted against the published Intel ABI, and cmcp PR #529 narrows hardware-validation.md so the validated TDX run reads as covering the DCAP quote path and not the TDREPORT path, because no TDREPORT capture exists yet. I would rather state that than let the row be read wider than the evidence behind it.

    Corrections to this RFC

    Two claims in the body above were wrong and are now fixed. Recording them here rather than editing quietly:

    • It said reference SDKs in Python and TypeScript are live. Only Python exists; a TypeScript SDK is on the roadmap and not started. The conformance vectors are the portable contract a second implementation would be written against, and #315 tracks that work.
    • The SDK release was listed as python-v0.5.0. Current is python-v0.11.0.

    Where this leaves the ask

    Phase 1 was feedback collection and this is not yet a request to accept. What has changed is that the three questions WS4 would have to answer before accepting are now answerable from the record rather than from assertion: whether the pre-execution claim is sound (§3.2.7.1, merged, and §5.1.2, in review, say what it does and does not cover), whether the enforcement side is honest about its own gaps (the TDX finding, and how it was found), and whether feedback changes the specification (six reviewers, every finding dispositioned in writing, one proposal accepted in substance rather than literally and one accepted in full, all in one query).

    @sarahnovotny @imolloy @claurau — the ask for the next WS4 meeting is a decision on whether Agent Manifest v0.x is submitted into the WS4 repo as a formal contribution alongside the Identity and MCP Security work, and on opening the co-editor seats. TII is confirmed; Intel and AMD have joined as endorsing organizations and NVIDIA is in progress. If the answer is not yet, the useful form of that answer is which of the items above is insufficient, and I will treat it the way #371 was treated.

  10. Mayur021 commented on Aug 18, 2026

    @Mayur021
    Member

    The TDX finding is the one I would put in front of anyone who still thinks round-trip tests establish correctness. Producer and verifier each carried their own copy of the offsets, both wrong the same way, so every test passed while the measurement was 48 bytes of the guest's own nonce. A symmetric error is invisible to any test that only compares the two sides to each other, and the thing that catches it is asserting against the published ABI, which is what you did. That is a stronger argument for this RFC than the acceptance table is, because it is the enforcement side reporting a defect in itself rather than a reviewer reporting one.

    One small thing about the record rather than the substance. My entry sits under "The two rejections", and its own text says both asks landed plus a correction to the overview paragraph. Nothing of mine was rejected in either sense the preamble defines. The body is right and the heading is not, which is the shape the section above it is about.

    And a question with an easy answer. The evidence base you point WS4 at is a label query, and agentrust-io/agent-manifest#313, on risk_tier setting the approval bar without ever being defined or bound, was filed this morning without cosai-ws4 on it. If it is out of scope for this review then say so and it stays where it is. I raise it only because "queryable rather than asserted" is only as strong as the query is complete.

  11. imran-siddique commented on Aug 18, 2026

    @imran-siddique
    Author

    Thank you — both points are right.

    I corrected the Phase 2 record in place. The section is now “Two proposals, two dispositions”: the OCSF identity proposal was accepted in substance rather than literally, while your §5.3/§7.2 proposal was accepted in full. The preamble and closing summary now say the same thing.

    #313 is in scope for this review. It was filed during the Phase 2 readiness pass by a WS4 reviewer, and its substance sits directly in review tracks 5/6: risk_tier controls the required approval strength but is neither normatively assigned nor bound to something a verifier can compare. I added cosai-ws4, so it is now present in the queryable evidence set.

    Disposition: accepted as a specification defect, not deferred as assessment work. The normative fix must define the assignment axis and make the declaration falsifiable to a reviewer without pretending a deploy-time verifier can infer per-call consequence. I will keep #313 open until that text and its conformance boundary land, then add the resulting PR to this Phase 2 record.

  12. 23 remaining items

  13. Levaj2000 commented on Sep 9, 2026

    @Levaj2000
    Member

    @imran-siddique @aeoess @darklordVirtual — following along, and I want to offer one piece of evidence-side infrastructure for the corpus.

    The three edge tests each need a runtime record that can carry "what actually resolved at the execution boundary" — otherwise the negatives have nothing concrete to fail against. The OCSF Discovery-class agent trust-base inventory filed upstream (ocsf/ocsf-schema#1724) is built for exactly that slot: it carries declared configuration and executed parameters in the same record, deliberately raw, with the record_integrity profile applied per emission (chain_uid/prev_event for ordering, authority_uid so a verifier confirms the signing credential belongs to the expected authority). The consumer computes the divergence; the producer doesn't.

    Two notes on how it maps to the seam work here:

    1. It preserves the non-transitivity frame. The trust-base record is runtime evidence only — it makes no claim about authorization or enforcement. What passed at admission and what executed stay in separate records, joinable through stable references, so a passing corpus can't let claims leak across layers. Same principle @darklordVirtual is running in the REMORA interop gate: unsupported properties remain unsupported rather than inheriting a PASS from an adjacent layer.
    2. On vocabulary: the not_established result with a reason maps cleanly onto how we treat gaps in the emission contract. If read-back can't be performed, that's a missing input, not a pass and not a failure — I'm glad that's being built into the vectors from the start.

    I'm co-drafting the class PR for 1.10 and have a verifiable worked sample running the same profile — Rev 2, an admission/closure pair shape where an admission with no closure is itself a structurally checkable gap, chained with the merged record_integrity profile. Our production emitter writes that same shape on API Activity 6003 today. Happy to run the vector set against it once the boundary statement and fixture shape land, or to review them from the OCSF side first — whichever helps more.

  14. aeoess commented on Sep 9, 2026

    @aeoess

    I ran @darklordVirtual's decision-to-effect-v1 set before settling the fixture shape. At b0e0cbee I reproduced all 15 REMORA results. I also ran the empty skeleton adapter and it reported 15 unsupported, zero passes. This is a reproduction of Stian's suite and adapter, not an independent implementation result.

    For our corpus I would keep the shape small: one positive control, then one negative for each of the three properties.

    Exact call: mutate an argument after authorization and require dispatch to refuse for that reason. REMORA V-02 already covers this.

    Non-bypassability: exercise a second path to the same downstream credential that does not go through the PEP. No REMORA vector currently expresses this, because its effectful adapter methods all require the handle returned by authorize.

    Effect: let the tool report success but have the declared read-back disagree. REMORA V-13 covers that shape. If read-back cannot be performed, the result is not_established with a reason, not pass or fail.

    One distinction from the REMORA set is worth keeping. V-14's EFFECT_INDETERMINATE is an expected runtime outcome and can be a matching vector result. not_established here is about whether the evidence establishes the property. A case can correctly report it, but the underlying property remains unestablished.

    The fixtures themselves should also state what a passing run does not prove: policy correctness, trustworthiness of the read-back source, absence of other bypass paths, or causation of the observed effect.

    @darklordVirtual I'm treating your set as prior art to run and cite, not copy. If you want V-02/V-13 represented directly in the Apache corpus, we can handle that separately.

    @Levaj2000 I'd like your read on whether these evidence inputs map cleanly onto the admission/closure records you described without making the fixture depend on OCSF.

  15. Levaj2000 commented on Sep 9, 2026

    @Levaj2000
    Member

    @aeoess — good shape, and yes, the mapping is clean. The pair is a structural pattern, not a schema, so the fixture doesn't need OCSF — OCSF is just one serialization of it.

    Property by property:

    • Positive control: admission authorizes C(args); closure shows C(args) dispatched and read-back agreeing. Both records present, fields join. Nothing more needed.
    • Exact call: admission carries the authorized args; the closure carries what dispatch actually saw. Mutated args after authz show up as admission/closure divergence, and "refuse for that reason" is the closure carrying the refusal reason. The evidence is the pair, not either record alone.
    • Non-bypassability: this is the one that stretches the shape, but in the direction it already handles. A bypassed PEP means an effect with no admission — the mirror of the gap I mentioned last time (admission with no closure). The checkable signal is the absence: a closure-side fact (credential used) with no admission covering it. Refused attempt → closure records the refusal, property holds. Successful bypass → unpaired effect, property violated.
    • Effect: the closure carries both the tool's self-report and the independent read-back, raw — the checker computes the divergence, the producer doesn't. Same "deliberately raw" discipline as the trust-base record. Read-back unavailable → not_established with a reason is exactly the missing-input case: well-formed closure, unestablished property.

    On V-14 vs not_established: agreed, and the pair shape keeps the two layers apart naturally. A closure faithfully reporting indeterminacy can satisfy the vector's expected shape while the property verdict remains not_established — the record is a claim, the verdict is the checker's, and neither inherits from the other.

    On the non-coverage statement: keep it at the corpus level, not in the records. The records stay raw claims; the boundary statement says what no passing run upgrades into. Same discipline, stated once per corpus instead of once per record.

    On OCSF dependence: none required. The fixture can define its own minimal pair — admission (authorized intent), closure (observed outcome), joined by a stable reference. Our #1724 / 6003 Rev 2 sample is then one worked binding of that shape. Happy to run the vectors against it once the fixture lands, or review the fixture shape from the evidence side first — whichever is more useful.

  16. darklordVirtual commented on Sep 9, 2026

    @darklordVirtual

    @aeoess yes, I think that is the right way to use them.

    Please treat V-02 and V-13 as prior art and re-express the scenarios in the Apache corpus rather than making the corpus depend on the REMORA fixtures or adapter. A pinned reference back to the REMORA vector revision is enough to preserve provenance.

    I agree with the gap you identified on non-bypassability. The current REMORA suite can test authority presented through its governed execution path, but it does not independently establish that no alternate path to the same protected effect exists. That deserves its own negative vector rather than being inferred from the other cases.

    I would also keep the distinction you made around V-14: EFFECT_INDETERMINATE is a valid runtime outcome, while not_established is the conformance/evidence verdict about whether the property was actually demonstrated. Those should stay separate.

    Happy to review the boundary statement and fixture shape before the corpus is implemented.

  17. aeoess commented on Sep 9, 2026

    @aeoess

    @imran-siddique following up on the reciprocity offer. draft-pidlisnyi-aps-03 now has a public runnable suite pinned at:

    https://github.com/Agent-Authority-Conformance/aps-conformance-suite/tree/b32ae4829d0c737e8f2461a7ad683a1157a135b5

    Full runner:

    bash scripts/run-all.sh

    The requirement map is in docs/ID-COVERAGE.md: 82 normative requirements, currently 5 EXERCISED, 28 PARTIAL, and 49 NOT EXERCISED. Those are coverage labels, not a pass rate or conformance score. The gaps are left explicit on purpose.

    For the five EXERCISED rows, the assertions reduce to two runnable checks:

    npm run cross-stack:oracle-safety-check:falsify
    npm run cross-stack:argentum-action-ref-v1v2:verify

    One note on the full runner: it preserves interop:a2a-go-368-jcs as a real failing reproduction rather than turning it green, so a full run is not expected to be all PASS.

    Same terms as your review: if you find a coverage claim the evidence doesn't support, a runner that can pass without exercising what it names, or an ambiguity in the draft, send it over and I'll treat it as a finding rather than argue around it.

  18. aeoess commented on Sep 9, 2026

    @aeoess

    @darklordVirtual yes, that works for me. I'll express V-02 and V-13 as new cases in the Apache corpus and keep a pinned REMORA reference for provenance. The bypass case will get its own negative instead of being inferred from the other cases.

    I'll send you the boundary statement and fixture shape for review before implementation. For now I'll treat it as lab work in the conformance suite. Whether it becomes a CoSAI deliverable is for the workstream to decide.

  19. darklordVirtual commented on Sep 10, 2026

    @darklordVirtual

    @aeoess, one thing that may be useful before the boundary statement and fixture shape are frozen.

    I encoded the evidence-sufficiency distinction we were discussing as a small synthetic checker and regression artifact:

    darklordVirtual/REMORA-research@f10ca2a

    The main result is not the case count, but the inference boundary it makes executable:

    • missing admission evidence is not equivalent to an observed bypass unless the relevant observation scope is independently established as complete;
    • a refusal does not establish which boundary caused it without an isolating control and accepted attribution evidence;
    • runtime outcome, expected-case match, and property verdict remain separate.

    The artifact includes two indistinguishable-history witnesses where identical verifier inputs correspond to different underlying histories. The checker therefore has to return NOT_ESTABLISHED until distinguishing evidence is supplied.

    I kept this additive to decision-to-effect-v1, so the existing 15-vector provenance and the revision you already reproduced are unchanged.

    The committed run is deliberately labeled synthetic author-run. It is not production evidence, independent validation, APS conformance, or a CoSAI conformance claim.

    If useful for the Apache fixture work, I think the reusable piece is the observation contract and inference rule rather than the REMORA-specific implementation.

  20. imran-siddique commented on Sep 11, 2026

    @imran-siddique
    Author

    Two public review rounds are done on this. @imolloy and @sarahnovotny both pushed hard on the proposal, six outside reviewers filed changes, and those changes were made. The RFC has been open since 27 July and it was an action item.

    Ask: approve it, set the label, and close this as complete. Nothing else is needed from the workstream on it.

    Two notes so the close is clean rather than leaving loose ends behind it.

    Scope. Agent Manifest is where this aligns with the Agent Credentials work, and I would put the boundary this way: a credential carries identity, authority, audience and status for a decision being made now; the manifest is the deployment-time record of what was approved to run, and a credential references a manifest by digest. Neither absorbs the other. TRACE is not being contributed here; that continues on the AAIF path.

    The adjacent material gets its own home. The evidence-sufficiency work discussed on this thread, decision-to-effect-v1, the corpus and the indistinguishable-history witnesses, is a separate proposal and it deserves its own RFC rather than living under this one. I will open that this week and link it here, so it is tracked properly and this thread can close without dropping it.

  21. imolloy commented on Sep 24, 2026

    @imolloy
    Contributor

    Thanks @imran-siddique for the sustained work here, and to everyone who has filed against it. I want to separate two things that have become entangled in this thread: whether WS4 has interest in this topic, and what WS4 would be accepting.

    I think there is a place for something like this. I would also like us to define the whole lifecycle rather than one artifact at a time: manifest, credentials, provenance. We already have pieces in flight for credentials (#99) and for provenance, so the boundary work matters more than any single record format.

    Proposed RFC lifecycle for WS4

    I would like to propose we adopt the following for this and future proposals.

    1. Open an INTEREST issue. This gauges interest in a topic, which may be broad, narrow, or abstract. It is not acceptance of anything formal. It requires demonstrated interest from representatives of multiple companies to move forward. On that basis the issue is labeled accepted.

    2. Open a PR with the RFC text. The PR adds RFCs/RFC-{num}.md to main and closes the issue on merge. This gives us one authoritative place where the RFC's scope and status live, reviewable by direct suggestion and diff rather than by comment thread.

    3. Once accepted, the work begins. Context, specification, implementation, and conformance material arrive as their own PRs referencing the RFC. Each needs a named lead or leads. Work can proceed in a branch with the TSC and WS leads gating merge to main. In some instances, the acceptance of the PR may close the work.

    Why I am proposing it here

    The difficulty with #149 as it stands is that the RFC text, the discussion, and the pointers to an external reference implementation cannot be separated. I cannot answer two basic questions from the thread: what exactly are we accepting, and what is the authoritative form of it?

    Concretely, reading the issue body against the spec on main in agentrust-io/agent-manifest:

    • The issue says the spec header now names CoSAI WS4 and that two AAIF references remain. The header on main still reads "Target Standards Body: Agentic AI Foundation (AAIF)" and "Aligns: CoSAI WS1," and AAIF also governs the @context URL (§3.1), the scanner registry (§3.2.5), and a planned MCP SEP (§6.3.1).
    • The issue positions this as a pre-execution declaration and explicitly not identity. The spec's subtitle is "A cryptographic identity and provenance standard for AI agents," §1.1 is "The Agent Identity Gap," and it describes the manifest as a "single tamper-evident identity primitive." That is the overlap with [RFC] Agent Credentials #99, in the normative text.
    • §3.2.8 requires container_image_digest to match the TEE launch measurement, which covers firmware and initial guest image rather than a container digest. Closing that gap needs the measured runtime layer that cmcp #432 and #433 say is not there yet.
    • The EU AI Act framing needs updating. Regulation (EU) 2026/1744 entered into force on 27 July 2026 and deferred Annex III high-risk obligations to 2 December 2027 and Annex I to 2 August 2028, so "binding August 2, 2026" no longer holds as an urgency argument or as the basis for review track 8.
    • The spec carries normative MUSTs for platform profiles that have no implementation. Only SEV-SNP and TDX are claimed as hardware-validated, yet §3.3.1 specifies AWS Nitro, NVIDIA Blackwell, ARM CCA, and Confidential Space as requirements. The Blackwell profile requires writing a "custom SPDM measurement index 0x05," and SPDM has no requester-supplied measurement write; measurements are produced by the responder. (This was flagged by my review and needs someone authoritative to chime in).

    There are also genuinely useful findings buried in the thread, including the issuer trust-anchor gap, the composite Merkle leaf encoding, and the decision-to-effect non-transitivity framing. Those deserve to be tracked as scoped work items rather than lost in a long comment history that is difficult to read end to end and in places contradicts itself.

    None of this is an argument against the topic. It is an argument for a form where need, scope, and accepted content are separable.

    The ask

    I would like a technical discussion on RFC 149 rather than an approve-and-close. Specifically:

    1. Confirm interest in the topic and label the issue accordingly, on the multi-company bar above.
    2. Open an RFCs/RFC-149.md PR containing the RFC text only: problem statement, scope, explicit non-goals, and the relationship to [RFC] Agent Credentials #99 and the provenance work. No reference implementation claims, no conformance assertions that are not yet demonstrable.
    3. Take the specification, implementation, and conformance work through separate PRs against that RFC, with named leads.

    One more reason to get the scoping right first: there is real overlap with ODIS, where Passport, Agent Credentials, and Agent Manifest occupy adjacent space. We should not ratify a boundary in one of them without a crosswalk across all three. I would rather spend a session on that than on approving a record format whose relationship to the others is still being worked out in comments. I'll propose a Discussion Topic: #209

    Happy to help draft the RFC-149 text and to take the ODIS crosswalk.

  22. imran-siddique commented on Sep 29, 2026

    @imran-siddique
    Author

    @imolloy agreed on the lifecycle, and step 2 is ws4#210, which adds RFCs/RFC-149.md as the RFC text alone.

    I checked your five spec points against agent-manifest main. Two were already fixed there: the header names CoSAI WS4, and the EU AI Act section carries the 2026/1744 dates. The other three were wrong and are corrected in agentrust-io/agent-manifest#471: the identity framing in the subtitle, abstract and section 1.1; section 3.2.8's claim that a container digest matches a TEE launch measurement; and the Blackwell profile writing an SPDM measurement, which a requester cannot do. Glad to take the ODIS crosswalk session on #209.

  23. imran-siddique commented on Oct 1, 2026

    @imran-siddique
    Author

    October 1 status and actions, following the updates on discussion #228.

    The Phase 1 disposition was posted August 12; the Phase 2 record followed August 18. The integration diagram and record boundaries are also published. Both original drafting/posting actions are complete.

    The scope-only RFC is now #210. The three external-spec corrections discussed above merged in agent-manifest#471. This does not imply acceptance of that external specification.

    AI assistance: researched and drafted with OpenAI Codex at my direction.

  24. imran-siddique commented on Oct 7, 2026

    @imran-siddique
    Author

    Status after the 2026-10-07 call: the standalone manifest folds into the ODIS Agent Registration Record, which becomes the single source of truth. What this RFC specifies carries forward as typed references and a named profile on that record. The field-by-field mapping is cosai-oasis/ws4-odis#35, discussed on #209. #210's scope text describes a standalone spec and is now out of date; whether it becomes a profile scope or closes is for the 2026-10-14 call.

  25. imran-siddique commented on Oct 15, 2026

    @imran-siddique
    Author

    Closing. The 10-07 call folded the Manifest into the ODIS registration record, so this continues as the profile in #210 and the field mapping in cosai-oasis/ws4-odis#35.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions