AgentAssert: Contract Enforcement for AI Agents

• AgentAssert is the reference implementation of the Agent Behavioral Contracts (ABC) framework, specifying preconditions, invariants, governance constraints, and recovery mechanisms.
• It operationalizes low-latency, probabilistic compliance and behavioral drift modeling to ensure robust safety and liveness properties in dynamic AI agent environments.
• The modular Python library supports multi-agent contract composition, real-time monitoring, and empirical benchmarking with sub-10 ms enforcement overhead for efficient agent governance.

AgentAssert is the reference implementation of the Agent Behavioral Contracts (ABC) framework, providing formal, runtime-enforceable behavioral guarantees for autonomous AI agents. It instantiates Design-by-Contract principles for agentic AI, enabling the specification of preconditions, invariants, governance policies, and structured recoveries as first-class artifacts. AgentAssert operationalizes ABC via a modular Python library with low-latency runtime enforcement, supporting rigorous probabilistic satisfaction guarantees, behavioral drift bounding, multi-agent contract composition, and empirical benchmarking.

1. Formal Structure: Agent Behavioral Contracts

At the core of AgentAssert is the ABC contract structure, defined as a 4-tuple $C = (P, I, G, R)$. Each component is a first-class, runtime-enforceable artifact:

• Preconditions ($P$): Finite set of predicates $p_1, ..., p_m$ over the initial agent state $s_0$ required to hold before execution (e.g., "user identity verified").
• Invariants ($I$): Partitioned into:
  • Hard invariants ($I_{\mathrm{hard}}$): Safety-critical properties that must be maintained at every step (e.g., "no PII is emitted," "no unauthorized trades").
  • Soft invariants ($I_{\mathrm{soft}}$): Desirable but recoverable properties (e.g., "response tone remains professional"), requiring restoration within $k$ steps.
• Governance Constraints ($G$): Predicates over agent actions $a_t$, split into:
  • Hard governance ($P$0): Zero-tolerance constraints (e.g., "no forbidden API calls").
  • Soft governance ($P$1): Advisory constraints (e.g., cost warnings).
• Recovery Mechanism ($P$2): Partial function $P$3, where, for a violated soft constraint $P$4 and state $P$5, it yields a bounded sequence of corrective actions to reestablish compliance. Failure to recover triggers a RecoveryFailed event.

In this framework, hard constraints operationalize safety ("nothing bad ever happens"), while soft constraints with bounded recovery provide liveness guarantees ("something good happens within $P$6 steps").

2. Probabilistic Satisfaction and Compliance Guarantees

AgentAssert extends contract satisfaction to stochastic, non-deterministic agents via $P$7-satisfaction:

Let $P$8 and $P$9 denote the fraction of hard and soft constraints satisfied at step $p_1, ..., p_m$0, for a session of length $p_1, ..., p_m$1. An agent $p_1, ..., p_m$2 $p_1, ..., p_m$3-satisfies contract $p_1, ..., p_m$4 (notation: $p_1, ..., p_m$5) if, with probability at least $p_1, ..., p_m$6:

• Persistent compliance (Hard guarantee):

$p_1, ..., p_m$7

• Recoverable compliance (Soft guarantee):

$p_1, ..., p_m$8

Here, $p_1, ..., p_m$9 bounds tolerable simultaneous soft constraint failures, and $s_0$0 specifies the recovery horizon. These principles correspond to probabilistic computation tree logic (PCTL) statements for safety and liveness under stochastic policy execution.

3. Behavioral Drift: Modeling and Theoretical Limits

AgentAssert incorporates behavioral drift modeling to quantify agent deviations from contract compliance. Drift $s_0$1 is modeled as an Ornstein–Uhlenbeck process:

$s_0$2

where:

• $s_0$3: natural drift rate (uncontrolled agent divergence),
• $s_0$4: recovery strength (contract enforcement efficacy),
• $s_0$5: process noise amplitude,
• $s_0$6: standard Wiener process.

The Drift Bounds Theorem establishes:

• Stationary drift: $s_0$7,
• Mean drift bound: $s_0$8 (enforcement cap),
• Variance: $s_0$9,
• Tail bound: $I$0,
• Exponential convergence: $I$1,
• Contract design criterion: For drift below $I$2 with probability $I$3, select

$I$4

with the low-noise limit $I$5.

This formalization enables engineering behavioral contracts with explicit drift and recovery guarantees (Bhardwaj, 25 Feb 2026).

4. Contract Composition in Multi-Agent Chains

AgentAssert supports composition of ABCs for multi-agent deployments, with the following guarantees:

• Serial composition: Given contracts $I$6, $I$7 for agents $I$8, $I$9, and handoff invariant $I_{\mathrm{hard}}$0, serial composition $I_{\mathrm{hard}}$1 is well-formed if:
  • Interface compatibility: $I_{\mathrm{hard}}$2,
  • Assumption discharge: $I_{\mathrm{hard}}$3,
  • Governance consistency: allowed actions of $I_{\mathrm{hard}}$4 do not conflict with prohibitions in $I_{\mathrm{hard}}$5,
  • Recovery independence: $I_{\mathrm{hard}}$6 preserves $I_{\mathrm{hard}}$7.
• Probabilistic degradation: If agent $I_{\mathrm{hard}}$8 is $I_{\mathrm{hard}}$9-satisfying and $I_{\mathrm{soft}}$0 is $I_{\mathrm{soft}}$1-satisfying, the composed chain $I_{\mathrm{soft}}$2-satisfies its composed contract with:

$I_{\mathrm{soft}}$3

where $I_{\mathrm{soft}}$4 are success and drift parameters for the handoff.

For $I_{\mathrm{soft}}$5-agent chains, $I_{\mathrm{soft}}$6 and $I_{\mathrm{soft}}$7. This formalizes multi-agent reliability under ABC/AgentAssert (Bhardwaj, 25 Feb 2026).

5. AgentAssert Architecture and API

AgentAssert is a modular Python library with overhead $I_{\mathrm{soft}}$810 ms per action, designed for practical integration and extensibility. The key layers include:

• Parser & Validator: Loads ContractSpec YAML contracts, validates schema consistency.
• Constraint Evaluator: Checks $I_{\mathrm{soft}}$9 predicates against agent state/action; computes $k$0, $k$1.
• Metric Tracker: Maintains JSD-based drift $k$2, compliance time series, recovery logs, and stress resilience index $k$3.
• Runtime Monitor: Orchestrates enforcement per agent turn—evaluates constraints; updates drift and compliance; emits violation/drift events; handles recovery via $k$4 if needed; resets state on re-satisfaction.
• Recovery Executor: Dispatches corrective actions per a taxonomy (LLM re-prompt, tool call, human escalation).
• Integration Hooks: Framework-agnostic adapters for LangChain, AutoGen, and custom agent infrastructure.
• Benchmark Runner: Supports evaluation on synthetic AgentContract-Bench and live agent sessions.

Example API usage (pseudocode):

$P$03 Under typical enterprise contracts ($k$5 constraints, $k$6 action types), the total overhead is 5–10 ms per action, much less than LLM inference latency (200–2000 ms) (Bhardwaj, 25 Feb 2026).

6. Benchmarking and Empirical Results

AgentAssert is evaluated on AgentContract-Bench, comprising 200 scenarios across five domains, 50 governance stress profiles, and 50 composition cases. Each scenario consists of a 5–8 step trace with ground-truth violation annotations.

Metric	Value/Range	Notes
Detection Accuracy	1.0000 (all scenarios)	All annotated violations flagged
Hard Compliance ($k$7)	$k$8–$k$9 (domains), $G$0 (stress), $G$1 (composition)	Safety-critical constraint adherence
Soft Compliance ($G$2)	$G$3–$G$4 (domains), $G$5 (composition)	Liveness property adherence
Mean Drift ($G$6)	$G$7–$G$8 (domains), $G$9 (composition)	Behavioral divergence measure
Reliability Index ($a_t$0)	$a_t$1–$a_t$2 (domains), $a_t$3 (composition)	Composite performance score (Def. 3.12)
Overhead	$a_t$410 ms/action	$a_t$5 constraints

In 1,980 live E1 sessions across seven LLM models and six vendors, contracted agents surface 5.2–6.8 soft violations/session vs. 0.0–0.3/session (uncontracted), with $a_t$6 (Welch's $a_t$7-test, Bonferroni correction), $a_t$8–$a_t$9, and power $P$00. Hard constraint compliance under stress is 88–100%; behavioral drift is bounded to $P$01; 100% recovery is observed for frontier models ($P$02), and 17–100% across all models, all at sub-10 ms enforcement overhead (Bhardwaj, 25 Feb 2026).

7. Significance and Applications

AgentAssert enables practitioners to specify, enforce, and monitor behavioral properties of autonomous agents with millisecond-level runtime checks, using formal YAML contracts and integration with popular LLM agent frameworks. The provision of probabilistic compliance guarantees and empirical drift bounding supports reliable agentic deployments under uncertainty and across composed workflows. As empirical results on AgentContract-Bench and live LLM deployments show, AgentAssert provides effective detection, high compliance, bounded behavioral drift, and robust recovery, addressing key governance and control gaps in agentic AI systems (Bhardwaj, 25 Feb 2026).