Implementation Guide

How to Build an AI Agent Change Advisory Review Packet

An AI agent change advisory review packet is a standardized set of artifacts, including permission diffs, tool-call and MCP connection manifests, runtime policy version history, and human review checkpoints, that gives a change advisory board the evidence needed to assess risk before approving changes to an autonomous agent's identity, permissions, or behavior.

Change advisory boards have decades of practice reviewing software releases: code diffs, test results, rollback plans. AI agents break several assumptions built into that model. An agent's behavior is not fully determined at deployment time. Permissions can be invoked dynamically at runtime, tool access can be expanded through configuration rather than code, and the same agent version can act differently depending on the tools and data sources it is connected to at a given moment. NIST's AI Risk Management Framework treats this as a lifecycle problem, calling for documentation of risk decisions on an ongoing basis rather than as a one-time gate. A packet built for a traditional software release, focused on code changes and functional test results, does not capture the artifacts a CAB actually needs to evaluate an agent change: what the agent is now permitted to do, what tools it can call, and what governance checkpoints exist if it acts outside expected bounds.

What Belongs in the Packet: Identity and Permissions

Agent identity records, including service account bindings and credential scope, are the starting point. Unlike a human user account, an agent's identity often maps to a set of dynamically invocable permissions rather than a fixed role. The packet should include a permission diff that shows the prior authorized scope against the proposed scope, structured so a reviewer can see exactly what access is being added or removed. This directly addresses the "Excessive Agency" risk category named in OWASP's guidance for LLM applications, which describes harm resulting from agents granted more permission, functionality, or autonomy than their task requires. OWASP's recommended mitigation, least-privilege scoping combined with logging of tool invocations, translates directly into two packet artifacts: the permission diff itself and a corresponding tool-call log covering the review period.

What Belongs in the Packet: Tool Calls and MCP Connections

The Model Context Protocol has introduced a standardized, versionable interface layer for connecting agents to external tools and data sources. This creates a new class of auditable artifact that has no direct equivalent in conventional software change packets: the MCP server connection manifest. Because MCP-specific risks such as tool poisoning and unauthorized capability injection have been documented by security researchers, any change that adds, modifies, or removes an MCP server connection should be treated as a distinct risk review item rather than bundled into a general application change. The packet should include a version-controlled manifest of connected MCP servers, the capabilities each one exposes, and a record of what changed since the last approved state. This gives the CAB a concrete basis for assessing third-party tool risk instead of relying on a general description of "added integration."

What Belongs in the Packet: Policy Version History and Human Review

Runtime guardrails, such as allowed action lists, rate limits, and escalation rules, are policy artifacts distinct from application code. These should be version-controlled and diffable, with timestamps, so a CAB can see precisely what governance behavior changed between agent versions, not just what code changed. NIST's Generative AI Profile recommends that organizations define clear escalation and human review processes for systems capable of autonomous or semi-autonomous action. The packet should include a log of human review checkpoints tied to the specific change under review: who reviewed the proposed permission or policy change, what escalation path exists if the agent's behavior deviates from the approved policy after deployment, and how that deviation would be detected. Without this evidence, a CAB is approving a behavioral change with no record of who is accountable for monitoring its effects.

Practitioner note

A packet lacking a human review log is not incomplete on formatting grounds; it leaves the CAB with no accountable party to contact if the agent's runtime behavior diverges from what was approved.

Core Components of an Agent Change Packet

Four artifact types form the minimum evidence base for a CAB to evaluate an agent change with the same rigor applied to conventional software releases.

Permission Diff

Prior vs. proposed agent scope, aligned to least-privilege review.

Tool-Call and MCP Manifest

Version-controlled record of tool and server connections.

Policy Version History

Diffable record of runtime guardrail and allowlist changes.

Human Review Log

Documented escalation and oversight checkpoints.

Assembling the Packet: A Practical Sequence

  1. 1

    Capture the current approved state

    Record the agent's existing permission scope, MCP connections, and policy version before any change is proposed, so the diff has a valid baseline.

  2. 2

    Generate the permission and manifest diffs

    Produce a structured, machine-readable diff of proposed permission scope and any new or modified MCP server connections.

  3. 3

    Attach policy version history

    Include the timestamped diff of runtime guardrails, allowlists, and escalation rules tied to this specific change.

  4. 4

    Document the human review checkpoint

    Record who reviewed the change, who holds escalation authority, and how post-deployment deviation would be detected.

  5. 5

    Submit for CAB review as a distinct risk item

    Present the packet separately from general application changes so agent-specific risk is not diluted within a broader release review.

Governance Considerations for CAB Review

There is currently no single published standard that defines the format of an AI agent change advisory packet. Organizations are adapting guidance from NIST AI RMF, OWASP's LLM application guidance, and MITRE ATLAS rather than following one compliance mandate. This has two practical implications for governance leaders. First, packet design should be treated as an internal standard that can be revised as frameworks mature, not a fixed template. Second, because NIST treats risk documentation as continuous, the packet should be built to support recurring review of an agent's behavior over time, not only the initial deployment decision. Escalation authority for autonomous action risk should also be defined separately from standard software change approval chains, since the person authorized to approve a code release may not be the appropriate authority to approve an expansion of agent autonomy.

Practical Guidelines for Packet Design

  • Keep the permission diff structured and machine-readable so it can be reused in future audits, not just the current review.
  • Treat every new MCP server or tool connection as its own line item in the packet, with its own risk notes.
  • Version every runtime policy artifact with a timestamp and identifier so changes are traceable across agent versions.
  • Extend existing change management tooling to capture agent-specific fields instead of building a parallel, disconnected process.
  • Record human review checkpoints explicitly, including who has authority to approve autonomous behavior changes.

Bring Structure to Agent Change Review

Trussed AI provides runtime governance, agent identity, and permission controls that generate the audit evidence a change advisory review packet requires.

Explore Runtime Governance