AI Agent Spending Limit Controls in Synclear Protocol

Spending limits are the quantitative enforcement layer within a mandate. Where the mandate schema defines what an agent is permitted to do, spending limits define how much — and they are checked by the MandateRegistry contract before every execution, making them a hard constraint rather than a policy advisory. No off-chain system can bypass them. Synclear implements a multi-tier spending limit model that gives principals fine-grained control over agent capital exposure at different time horizons and transaction patterns.

Limit Types

Per-Transaction Cap
Daily Rolling Limit
Lifetime Limit
Cooldown Periods
Rate Limiting

The per-transaction cap (maxTransactionAmount) is the most granular limit. It constrains the notional value of any single transaction submitted by the agent. The MandateRegistry checks the transaction’s asset amount against this cap as the first validation step.This limit is denominated in the asset’s native base units and is asset-specific when a mandate covers multiple assets. For example, a mandate permitting both USDC and USDT operations applies the same maxTransactionAmount to each asset independently.Use case: Prevents a compromised agent or runaway automation loop from draining a position in a single transaction.

The daily rolling limit (maxDailyVolume) constrains the total notional volume an agent may execute across all transactions within a 24-hour window. The registry accumulates executed volume against this limit and rejects any transaction that would cause the running total to exceed it.

Synclear uses a rolling 24-hour window for daily limit calculation, not a UTC midnight reset. The window looks back exactly 86,400 seconds from the current block timestamp. This prevents agents from concentrating large volumes at midnight boundaries and provides consistent protection regardless of timezone or scheduling patterns.

Volume is tracked per asset. An agent operating on both USDC and USDT has separate daily accumulators for each, each subject to the same maxDailyVolume value defined in the mandate.

On-Chain Enforcement

All spending limits are enforced by the MandateRegistry contract in a single validation call that precedes every execution. The contract evaluates limits in the following order:

Mandate existence and ACTIVE state check
Action type is within permittedActions
Asset is within allowedAssets
Mandate has not expired (block.timestamp < expiresAt)
Transaction amount does not exceed maxTransactionAmount
Adding this transaction would not exceed maxDailyVolume for this asset
Lifetime limit not exceeded (if configured)
Cooldown period has elapsed since last large transaction (if configured)
Rate limit window has not been exhausted (if configured)

If any check fails, the entire transaction reverts with a structured error indicating which check failed and the current state of the relevant limit. This allows agent implementations to handle rejections gracefully and schedule retries when appropriate.

Querying Current Usage

Agents and monitoring systems can query the current spending state for any agent address and asset pair directly from the MandateRegistry:

const usage = await mandateRegistry.getDailyUsage(agentAddress, assetAddress);
// returns { used: BigInt, limit: BigInt, resetAt: number }

The returned object contains:

used — cumulative volume executed by the agent in the current rolling 24-hour window, in the asset’s base units
limit — the maxDailyVolume defined in the agent’s active mandate for this asset
resetAt — the Unix timestamp at which the earliest transaction in the current window will age out, partially restoring available daily capacity

To query the per-transaction cap and rate limit state:

const limits = await mandateRegistry.getMandateLimits(agentAddress);
// returns {
//   maxTransactionAmount: BigInt,
//   maxDailyVolume: BigInt,      // nominal limit from mandate
//   effectiveDailyLimit: BigInt, // lower of maxDailyVolume and trust-score tier cap
//   lifetimeLimit: BigInt,
//   lifetimeUsed: BigInt,
//   rateLimit: number,           // max transactions per hour
//   rateWindowUsed: number,      // transactions used in current hour window
//   cooldownThreshold: BigInt,
//   cooldownEndsAt: number       // 0 if no active cooldown
// }

Limit Interactions with Trust Score

Spending limits defined in a mandate represent the maximum the agent is authorized to use. However, if an agent’s trust score falls below the threshold for its current limit tier, the MandateRegistry will apply the lower tier’s caps dynamically — even if the mandate nominally permits higher amounts. This means that a mandate with a maxDailyVolume of

500,000 will be operationally constrained to

100,000 if the agent’s trust score is in the Standard tier (201–500). See Trust Scoring for the full tier table and scoring mechanics.

When a mandate’s stated limit exceeds what the agent’s current trust score tier permits, the getMandateLimits response will reflect the effective limit (the lower of the two) in the effectiveDailyLimit field, alongside the mandate’s maxDailyVolume as the nominal limit. Always use effectiveDailyLimit when making runtime decisions in agent code.

Overview

Mandates & Limits

Accountability & Scoring

AI Agent Spending Limit Controls in Synclear Protocol

Limit Types

On-Chain Enforcement

Querying Current Usage

Limit Interactions with Trust Score

​Limit Types

​On-Chain Enforcement

​Querying Current Usage

​Limit Interactions with Trust Score

Limit Types

On-Chain Enforcement

Querying Current Usage

Limit Interactions with Trust Score