Implementation Guide

How to Write an AI Agent Capability Attestation

An AI agent capability attestation is a structured document that specifies exactly what an autonomous agent is authorized to do: which tools it can call, what data it can access, under what conditions, and with what constraints. Unlike a model card, which describes model behavior at a general level, a capability attestation is scoped to a specific deployed agent and is written so its contents can be enforced as runtime policy, not just reviewed as static documentation.

Why a Separate Artifact Is Needed

Enterprise teams deploying autonomous agents commonly rely on general model documentation, deployment tickets, or informal notes to describe what an agent is allowed to do. None of these are adequate for security review or audit. A model card, in its original form, was designed to disclose a model's intended use, limitations, and performance characteristics. It says nothing about which tools a specific deployed agent can invoke, what data it can read or write, or what happens when the agent attempts an action outside its intended scope.

A capability attestation fills that gap. It is scoped to a specific agent instance or agent class, not to the underlying model, and it documents operational permissions rather than model behavior. This distinction matters because two agents built on the same model can have entirely different risk profiles depending on what tools and data they are connected to. Risk teams, auditors, and customers asking about agent behavior boundaries need documentation at the level of the deployed agent, not the model.

What the Attestation Must Document

At minimum, a capability attestation should identify the agent, its owner, and the environment it runs in. From there, it needs to enumerate the specific tools, APIs, and systems the agent is authorized to call, along with the exact scope of data access for each: read-only versus read-write, which fields or records, and any data classification constraints.

It should also state action boundaries. This includes rate limits, transaction value ceilings, approval requirements for high-risk actions, and any actions the agent is explicitly prohibited from taking regardless of what its underlying model might attempt. Finally, it should note the conditions under which permissions were granted, such as the review that approved them and the date they were last validated. Without this level of specificity, the attestation is a description, not a control.

Capability Attestation vs. Model Card

Aspect Capability Attestation Model Card
Scope Specific deployed agent or agent class Underlying model in general
Content Tool access, data scope, action boundaries Intended use, limitations, performance
Purpose Runtime enforcement and audit General disclosure of model behavior

Mapping the Attestation to Enforceable Policy

A capability attestation that exists only as a document reviewed once at deployment time provides limited assurance. The document can drift from actual agent behavior as tools are added, data sources change, or configurations are updated outside the review cycle. To be useful for ongoing governance, the attestation should be written so its components can be translated directly into policy checks enforced at runtime.

In practice, this means each permission statement in the attestation should be specific enough to become a rule: which tool, which data scope, under which condition. If the attestation says the agent may query a customer database but not modify records, that statement should correspond to an enforceable check at the point where the agent attempts a database call, not just a line in a document that is filed away. Writing attestations with this level of specificity is what allows them to serve as the source of truth for both audit review and runtime enforcement, rather than two separate and potentially inconsistent artifacts.

Practices for Writing an Effective Attestation

  • Scope the attestation to a specific agent deployment, not a model or product line, so permissions reflect actual runtime context.
  • State data access in terms of read, write, or delete for each connected data source, not generic access levels.
  • Document prohibited actions explicitly, not only permitted ones, since absence of a permission is not the same as an enforced restriction.
  • Record who approved each permission and when, so the attestation can support audit trails and periodic re-review.
  • Write permission statements at a level of specificity that can be translated into a runtime policy check.
  • Version the attestation and require updates whenever tool access, data scope, or action boundaries change.

Governance and Review Implications

For governance leaders, the capability attestation becomes the reference point for several recurring processes: security review before an agent is deployed or its scope expanded, periodic re-certification of existing permissions, and audit response when internal risk teams or external auditors ask what an agent is authorized to do. Treating the attestation as a living artifact tied to an approval workflow, rather than a one-time document, keeps it aligned with how the agent actually behaves in production.

This also has implications for incident response. When an agent takes an unexpected action, the attestation is the reference document used to determine whether the action was within its authorized scope or represents a boundary violation. If the attestation is vague or outdated, this determination becomes difficult, which undermines both the audit value of the document and the ability to enforce least-privilege access in practice.

Reference

Core Components of a Capability Attestation

These are the elements a well-formed attestation should contain, corresponding to the practices described above.

Agent Identity

Unique identifier, owning team, and deployment context for the agent.

Tool and Data Scope

The specific tools, APIs, and data sources the agent is permitted to access.

Action Boundaries

Conditions, limits, and prohibited actions governing agent behavior.

Enforcement Mapping

How documented permissions translate into runtime policy checks.

Turn Attestation Into Enforcement

A well-written capability attestation documents what an agent should be allowed to do. Runtime governance ensures that documented scope is what actually happens in production.

Explore Runtime Governance