Back to all articlesAI action safety

Prevent Repeated Small AI Actions from Bypassing Overall Limits

Alactic Editorial10 min read

Prepared with AI assistance by Alactic Editorial. Examples identified as hypothetical are illustrative, not customer results.

An assistant updates a small batch of CRM records. A reviewer approves it because the batch is within the allowed size. The assistant proposes another small batch, then another. Each decision looks acceptable on its own, but together they change more records than the business intended to delegate.

Prevent this by authorising both the individual action and its cumulative impact. Define a shared actor scope, a stable target group, an impact measure and a rolling time window. Before execution, count completed work and outstanding reservations against every applicable limit. Reaching the cap should trigger a defined decision about further work, not merely another batch approval.

The ledger below is a fictional worked example, not an Alactic customer result. All example quantities, identifiers, thresholds, times and windows are hypothetical. These controls are a recommended operating design, not a claim about available product capabilities.

1. Limit business impact, not just batch size

A per-action limit answers, “How much may this action change?” A cumulative limit answers, “How much change may this delegated workflow cause altogether?” Splitting a large job into small actions must not expand its authority.

Choose a measure that captures the consequence you want to constrain. Counting requests is insufficient when one request can change many records. For record maintenance, useful measures include:

  • Mutation count: every successful record change consumes capacity, including repeated edits to the same record.
  • Distinct-record count: each record counts once within the window, measuring how widely changes spread.
  • Separate sensitive-action counts: ownership transfers or sensitive field changes may need their own limits.

Mutation count exposes repeated edits but consumes capacity during corrections. Distinct-record count measures reach but can conceal repeated changes. Enforce both if both consequences matter, rather than combining them into an unexplained score.

This is aggregate authorisation, not API rate limiting. A service may accept requests even when the business has no remaining authority to execute them. Waiting and retrying does not replace a required review.

2. Define whose actions and which targets count together

A counter attached only to a conversation is fragile. A restarted worker, new conversation or second reviewer could begin with an empty counter while continuing the same job.

Record the individual initiator for accountability, but charge related actions to a shared delegated-authority pool. Multiple workers carrying out one cleanup operation should draw from that same allowance. Define targets using stable workspace and cohort identifiers, not only a live search filter. Editing a record so it leaves the filter must not erase its earlier impact.

A usable policy record specifies:

  • Actor scope: the shared workflow and any broader workspace allowance.
  • Target scope: the stable record group covered by the authorisation.
  • Action class: the permitted changes.
  • Impact unit: what counts, including repeated edits.
  • Window: how long completed impact remains chargeable.
  • Pause and release rules: when execution stops and who may authorise a defined continuation.

Check overlapping limits together. A workflow can have spare capacity while its target group’s shared allowance is exhausted. Every applicable check must pass. Aggregate capacity also does not grant access to a record or field that the actor cannot otherwise edit.

3. Set window and hold rules before execution

A rolling window counts relevant completed impact during the period immediately preceding a decision, plus active reservations. It avoids the sudden replenishment associated with fixed reset boundaries. However, it still permits sustained activity over time; a finite job may also need a job-wide total.

For this hypothetical example, the policy permits at most 5 record mutations per action and 20 mutations in any rolling 60-minute window. All workers and reviewers acting for the workflow share the approved cohort’s allowance.

An action that reaches the cap may finish within its reservation, but reaching the cap places further execution on review hold. Capacity ageing out does not release that hold. This separates numerical room from permission to continue.

The example uses single-use releases: a reviewer may permit one identified action to be reconsidered while leaving the underlying scope on hold. The release does not raise the cap, reserve capacity or authorise another action. It is consumed when that action is admitted to execution, and is not restored by failure or partial completion. Retries belong to the same action and follow reconciliation rules.

This conservative choice suits work where exhausting an allowance could reveal an unexpectedly broad task. Automatic resumption may suit other workflows, but it should be an explicit policy choice.

4. Use a filled rolling-limit ledger

Fictional worked example: an operations workflow normalises a non-sensitive CRM classification field. The following filled artifact can serve as a model for a policy record and execution ledger. Every identifier, quantity and time is hypothetical.

POLICY
Actor pool: CRM-cleanup / Operations
Target group: C-17, pinned record membership
Action class: Classification-field update
Counting rule: Each successful record mutation counts
Per-action cap: 5 mutations
Rolling cap: 20 mutations / 60 minutes
At cap: Finish reserved action; hold further execution
Release authority: Designated operations reviewer
Release type: Single-use, bound to one exact action
Reservation bound: Named records and authorised field changes

FILLED LEDGER — same hypothetical day
Time   Event                     Counted total   Decision
09:00  A: R01–R04, 4 completed         4          Continue checks
09:10  B: R05–R09, 5 completed         9          Continue checks
09:20  C: R10–R12, 3 completed        12          Continue checks
09:30  D: R13–R16, 4 reserved         16          Admit D only
09:32  D: reservation becomes done   16          Continue checks
09:35  E: R17–R20, 4 reserved         20          Hold new actions
09:36  E: reservation becomes done   20          Hold remains
09:40  F: R21–R22, 2 requested       20          Block; no reservation
10:01  A: 4 completed mutations age  16          Hold remains
       out of rolling window
10:02  Reviewer grants release F-1   16          F only; hold remains
10:03  F: recheck; reserve 2          18          Consume F-1; admit F
10:04  F: reservation becomes done   18          Hold remains for all
                                                further actions

RELEASE F-1
Action: F only; records R21 and R22
Change: Previously reviewed classification-field update only
Maximum impact: 2 mutations
Cap change: None
Prerequisites: Current access and capacity checks pass
Lifecycle: Single-use; consumed on admission at 10:03
After completion: No further action authorised

At the hypothetical 09:35 decision, the reservation fills the allowance exactly. Completion converts reserved impact into completed impact; it does not add the same impact twice.

The hypothetical 09:40 request is blocked despite being small enough individually. Its projected total exceeds the rolling cap. Because it is not admitted, it receives no reservation.

At the hypothetical 10:01 check, earlier impact ages out, but the hold remains. The reviewer checks the prior results and F’s exact scope. The single-use release then permits F to undergo fresh access and capacity checks. When F finishes, the total is below the cap, yet every further action still needs separate authorisation. Remaining capacity is not permission.

5. Enforce reservations and retry protection

A ledger kept only in conversation history cannot safely coordinate parallel workers. Two workers could read the same remaining capacity and each act on it. Admission must check capacity and reserve it together in a shared authorisation process.

  1. Resolve the trusted actor pool, target scope, action class and policy version.
  2. Check permission for every proposed record and field, including any required release.
  3. Calculate the action’s bounded impact against all applicable limits and holds.
  4. Atomically reserve that impact across the limits and consume any single-use release, or reject admission without partial reservations.
  5. Execute only the authorised changes, with enforced idempotency or deduplication tied to a stable action identifier.
  6. Reconcile outcomes, converting confirmed successful impact into completed entries and releasing only confirmed unused capacity.

A stable identifier is not itself duplicate prevention. The execution system must enforce its meaning: a repeated submission must not reapply completed work. For partially completed batches, this can require tracking individual authorised changes as well as the parent action. Concurrent submissions must not both pass the deduplication check and execute.

If the execution system cannot enforce that protection, reconcile an unknown result before retrying. Reusing a label does not make a retry safe.

The reservation must also bound permitted execution, not merely estimate it. Bind it to the approved records, fields and maximum mutations. If execution would exceed that bound, stop before the additional changes and obtain a fresh reservation and any required authorisation. Spare capacity elsewhere is not an implicit extension.

OWASP’s authorisation guidance supports least privilege, default denial and permission checks on each request. Cumulative accounting adds an impact boundary; it does not replace those access checks.

6. Make review an explicit decision about remaining work

Show reviewers completed impact, active reservations, pending work, target scope and the reason for the hold. Otherwise, review can repeat the original error by considering only the next small batch.

Give the reviewer distinct decisions:

  • Stop: cancel remaining work because the purpose is complete or no longer justified.
  • Narrow: reduce the proposed targets or permitted changes.
  • Release one action: authorise a precisely identified action for fresh admission checks without lifting the general hold.
  • Request an exception: route a proposed expansion to someone authorised to change the aggregate allowance.

Record an exception’s scope, reason, approver and expiry conditions. Do not erase historical impact or reset counters to make room. A reviewer who can approve batches but cannot expand aggregate authority must not be treated as having done so.

In the example, the useful decision is “Permit F only, for the reviewed changes to R21 and R22, subject to the unchanged limits.” “Continue cleanup” leaves the next worker to invent its scope. If broader releases are needed, define their bounded remaining work explicitly rather than quietly reinterpreting a single-use release.

7. Reconcile failures without hiding impact

For partial execution, count confirmed successful mutations and release only the portion confirmed not to have occurred. A timeout is not proof of failure. Keep uncertain impact reserved and hold affected work until reconciliation establishes the outcome.

If actual impact is lower than the reservation, release the verified unused portion. If reconciliation discovers impact above the reserved bound, record the full actual impact, even when that makes the ledger exceed the cap. Hold further affected execution and investigate the control failure. Never truncate actual impact to the reservation or describe the excess as retrospectively authorised.

That overrun procedure is containment, not a substitute for prevention. The execution boundary should have stopped additional changes until a fresh reservation was obtained.

  • Restarted workflow: recover the existing authority pool and ledger, not a new allowance.
  • Parallel approvals: share capacity; approvals do not create separate budgets.
  • Changed cohort: retain historical membership and impact rather than recomputing history from a live filter.
  • Unavailable ledger: hold execution instead of interpreting missing data as unused capacity.
  • Corrective edits: record their impact and obtain appropriate authority; do not subtract the original changes as though they never occurred.

Keep unresolved reservations visible. Expiry may trigger investigation, but elapsed time alone does not prove that execution never happened.

8. Test the boundary before expanding scope

Start with one low-consequence workflow and a filled policy record. Replay the hypothetical ledger: the action reaching the cap can finish; the next action is blocked; ageing impact does not clear the hold; F’s release admits only F; and F’s completion leaves further work held.

Also test concurrent admissions, duplicate submissions, partial completion, an unknown result and an attempted change beyond the reservation. Confirm that excess changes are stopped before execution. Separately test recovery from a discovered overrun: the ledger must show full actual impact and the affected scope must remain held.

Track blocked requests, unresolved reservations, review delays and differences between reserved and actual impact. Investigate mismatches before expanding authority. Frequent holds may indicate an overly broad job, not simply a cap that should be raised.

A reviewer should be able to determine from the policy and ledger alone who used the allowance, what changed, what remains uncertain and exactly which action—if any—may run next.

AI action safetyAuthorisationCRM operationsWorkflow governance

Put the next conversation to work.

Explore Alactic Communications for WhatsApp conversations, campaigns and AI-assisted workflows. Choose the product and plan that fit your team.

Explore Communications