Agent Contracts: Formal AI Governance

• Agent contracts are formal, enforceable specifications that regulate resource use, coordination, and outcome metrics in autonomous AI systems.
• They define a complete lifecycle with states like DRAFTED, ACTIVE, and FULFILLED to ensure compliance and auditability.
• Contracts enable hierarchical delegation, precise resource allocation, and tunable quality-resource tradeoffs for robust AI governance.

Agent contracts are formal, enforceable specifications that govern the execution, resource consumption, and coordination of autonomous AI agents within multi-agent systems. In contrast to legacy coordination protocols that focus on connectivity or task allocation, agent contract frameworks encode hard resource budgets, explicit success and termination criteria, and composable governance guarantees into a mathematically precise lifecycle model with auditable transitions and enforceable conservation laws. These structures enable predictable, resource-bounded, and auditable deployment of AI agents, supporting robust hierarchical delegation and principled trade-offs between cost, speed, and solution quality (Ye et al., 13 Jan 2026).

1. Formal Structure of Agent Contracts

An agent contract is specified as a tuple

$C \;=\; \bigl(I,O,S,R,T,\Phi,\Psi\bigr)$

with the following components:

• Input specification $I=(\sigma_I,\mathcal{V}_I,\mathcal{P}_I)$: schema, validation predicates, preprocessing transforms.
• Output specification $O=(\sigma_O,Q_{\min},\mathcal{F}_O)$: output schema, minimum quality threshold, formatting constraints.
• Allowed skills $S$: enumeration of accessible tools, APIs, knowledge domains.
• Resource budget $R=\{(r_1, b_1, c_1), \dots, (r_n, b_n, c_n)\}$: each resource $r_i$ with hard cap $b_i$, consumption function $c_i(t)$.
• Temporal constraints $T=(t_{\text{start}}, \tau)$: activation time and permitted execution duration.
• Success metrics $\Phi=\{(\phi_i, w_i ) \}$: weighted measurable predicates with fulfillment threshold $\theta$.
• Termination conditions $\Psi=\{ \psi_1 \lor \dots \lor \psi_\ell \}$: e.g., resource exhaustion, timeout, cancel, irrecoverable error.

While active, the agent must:

• Respect all schema/validation constraints on $I/O$,
• Never exceed any resource budget $b_i$,
• Complete within $\tau$,
• Achieve total success weight $\sum_{i} w_i\, \mathbf{1}[\phi_i] \geq \theta$,
• Halt upon any $\psi_\ell$ condition.

This contract schema unifies task specification, hard operational ceilings, and quantifiable delivery targets into a single, auditable governance object (Ye et al., 13 Jan 2026).

2. Contract Lifecycle and State Semantics

Agent contract execution is modeled as a finite-state machine with states:

• DRAFTED: contract drafted, awaiting activation.
• ACTIVE: resources available; running.
• FULFILLED: all obligations (hard and soft) satisfied; success weight exceeded threshold.
• VIOLATED: any hard resource bound or format constraint is breached.
• EXPIRED: time runs out before fulfillment.
• TERMINATED: externally cancelled.

State transitions are as follows:

• DRAFTED → ACTIVE if resources are provisioned.
• ACTIVE → FULFILLED if $\sum_i w_i\, \mathbf{1}[\phi_i] \geq \theta$.
• ACTIVE → VIOLATED if any $c_i \geq b_i$.
• ACTIVE → EXPIRED if $t-t_{\text{start}}>\tau$.
• ACTIVE → TERMINATED if an external cancellation is invoked.

Each transition is guardable (via log inspection), ensuring that enforcement and policy-compliance are audit-log verifiable (Ye et al., 13 Jan 2026).

3. Resource Conservation and Contract Delegation

For hierarchical multi-agent workflows, critical safety is preserved by budget conservation laws. If a parent contract $C_p$ specifies budgets $R_p=\{(r,b_p)\}$ and delegates sub-contracts $C_1, \dots, C_k$ each with $R_j=\{(r,b_j)\}$, the invariant is:

$\forall r: \sum_{j=1}^k b_j^{(r)} \leq b_p^{(r)}$

By induction on delegation depth, no agent can collectively allocate more resources than originally provisioned. Unused budgets "flow back" to the parent pool, ensuring global resource usage is always bounded by the root contract allocation. This conservation ensures robust global governance in arbitrarily deep contract hierarchies (Ye et al., 13 Jan 2026).

Delegation Example:

Given a parent contract allocating 10,000 tokens and 50 API calls, two subtasks may receive 4,000/20 and 5,000/25, respectively, with delegated budgets guaranteed to sum within the parent's limits. Upon task completion, unused budgets are returned and may be reallocated dynamically (Ye et al., 13 Jan 2026).

4. Quality-Resource Tradeoffs via Contract Modes

Agent contracts parameterize (resource, quality, time) tradeoffs via "contract modes." Let $$M \in \{\mathrm{URGENT}, \mathrm{ECONOMICAL}, \mathrm{BALANCED}\}$$; the following tunings are typical:

$$R_{\rm tok}(M)= \begin{cases} r_{\rm in}+0 & M=\mathrm{URGENT} \ r_{\rm in}+700 & M=\mathrm{ECONOMICAL} \ r_{\rm in}+1500 & M=\mathrm{BALANCED} \end{cases}, \quad \tau(M)=\{30,\,60,\,90\}\mathrm{s}, \quad \theta(M)=\{\mathrm{exact}, \geq 80\%, \geq95\%\}$$

Empirical evaluation demonstrates that tightening contract parameters reduces cost and time, at predictable losses in solution quality (URGENT: 70% success, BALANCED: 86%), operationalizing the satisficing principle (Ye et al., 13 Jan 2026).

5. Empirical Evaluation and Performance

Across four benchmarks—code review, research pipeline, strategy modes, and crisis communication—contract-governed workflows exhibit:

Experiment	Uncontracted (Key Metric)	Contracted (Key Metric)
Code Review	34,606 tokens, $5.29 \times 10^{9}$ var	3,461 tokens, $1.01 \times 10^7$ var
Research Pipeline	0/50 conservation violations (after)	0/50 conservation violations (none)
Strategy Modes	70% success	86% success
Crisis Comm.	1/24 failure	0/24 failure, 23% token reduction

Key outcomes:

• 90% token reduction, 525x variance reduction, 43% fewer refinement loops in code review,
• Zero conservation violations under contract enforcement,
• Measurable, tunable tradeoff between expenditure and solution quality via modes,
• Failure cases (runaway loops, stuck evaluations) eliminated in contracted regime (Ye et al., 13 Jan 2026).

6. Foundations for Predictable and Auditable AI Governance

Agent contracts enforce:

• Predictability: By bounding worst-case per-invocation resource use.
• Auditability: All lifecycle transitions and consumption events are logged for traceability.
• Composability: Hierarchical delegation respects the top-level budget invariant.
• Flexibility: Modes allow explicit trade-offs between cost, speed, and outcome guarantees.
• Automatic fail-safety: Violations (runaway loops, resource escalations) force immediate termination, preventing silent cost blowup.

This institutes a shift from ad hoc "guardrails" to formally composable, enforceable, and inspectable resource-governance for autonomous AI (Ye et al., 13 Jan 2026).

7. Broader Impact and Theoretical Context

Agent contract formalisms extend classical "contract nets" from task allocation to holistic, multi-dimensional resource and success governance, filling the gap left by traditional agent protocols. They unify operational and governance-level constraints, providing rigorous tools for large-scale, autonomous, and auditable deployment of agentic AI. This paradigm supports scalable delegation, predictable expenditure, and transparent audit, all critical for trustworthy autonomous AI system operation (Ye et al., 13 Jan 2026).