Back to all articlesAI action safety

Authorise Multi-Step AI Actions Without Granting a Blank Cheque

Alactic Editorial9 min read

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

“Move the service visit to Thursday” sounds like one instruction. An assistant might interpret it as permission to change the appointment, reassign a preparation task, cancel a reminder and notify the customer. Those are separate actions. Approval of the outcome does not settle which ones the assistant may perform.

The practical answer is an action contract: a reviewable plan specifying the permitted records, fields, sequence, branches and stop points for one authorised attempt. Customer contact requires its own decision. So does recovery work that falls outside the original plan.

A contract is not an access control by itself. The execution layer must enforce it. This article explains a recommended operating design, with a fictional worked example that distinguishes approval from enforceable permission.

1. Approve the means, not just the result

Start by separating the surfaces an instruction might affect:

  • Service record: the scheduled start and end of one visit.
  • Internal task: the deadline of an existing preparation task.
  • External communication: a message telling the customer about the change.

Someone may have authority over all three, but approving one does not automatically approve the others. Permission to change a deadline does not include permission to reassign, reopen or replace the task.

Attach approval to a fixed plan version, not an evolving conversation. Include the targets, reviewed values, proposed changes, permitted reads, expiry and conditions for stopping. If the assistant changes the plan after approval, the new plan needs review.

OWASP’s authorisation guidance recommends least privilege, denial unless access is permitted, and permission checks on every request. A contract should complement those checks, never bypass them. Knowing a record identifier is not permission to edit it.

The trade-off is review effort. A field-level plan takes longer to approve than “make the necessary updates”, but it makes unauthorised intermediate actions visible.

2. Define three allowed record states

“Stop if anything changed” conflicts with “continue if it is already correct” unless the contract defines which already-correct states are acceptable. Use three explicit classifications:

  • Unchanged reviewed state: the record matches both the reviewed values and reviewed version. The approved write may proceed, subject to permission and dependency checks.
  • Authorised target state: the exact approved result has a trusted version reference. That reference must come either from a preview that reviewed the record already at that target, or from a confirmed write under this same contract. No write is needed.
  • Any other state: stop. This includes the desired values appearing under an unexplained new version.

This is deliberately conservative. A version change alone requires a refreshed preview and renewed approval unless it is the recorded result of this contract’s own confirmed write. An unrelated edit can matter even when the scheduling fields look unchanged.

The no-op branch follows the same rule. Merely finding the desired date does not permit continuation. The executor must also establish the approved version reference and unchanged protected fields. If the version mechanism cannot support that distinction, stop rather than guess.

For an uncertain write, a read can establish current values but may not establish who changed them. Without trustworthy evidence linking that version to this contract, matching values are not enough to resume.

3. Reuse this filled action contract

Fictional worked example: All names, identifiers, versions, dates, times and limits in this contract are hypothetical. Copy its structure, replacing the filled values with a reviewed plan. It describes recommended controls, not verified Alactic capabilities.

Identity and scope

  • Contract: AC-042, plan version 1; one execution attempt, with reconciliation allowed but no fresh replay.
  • Workspace: Harbour Service Operations.
  • Approver: Mira, service coordinator. Check her authority for each requested action at execution.
  • Targets: visit SV-1842, customer C-317, existing linked task T-662.
  • Approval: 13 October 2026 at 10:00, Europe/London. Every write must occur before 10:15 that day; expiry stops remaining writes.
  • Outcome: move this visit and adjust this task’s deadline. Customer contact is excluded.

Reviewed state and authorised changes

  • Visit baseline: version 17; 14 October 2026, 09:00–11:00, Europe/London; status Scheduled; assigned team Team North.
  • Visit target: 15 October 2026, 13:00–15:00, Europe/London. Change start and end only.
  • Task baseline: version 8; open; assigned to Leon; due 13 October 2026 at 16:00, Europe/London.
  • Task target: due 14 October 2026 at 16:00, Europe/London. Change due time only.
  • Protected values: leave all other fields unchanged, including links, customer, address, team, owner, status, price, titles and descriptions.

Permitted checks and execution

  1. Read the named records and linked customer identity. Verify targets, permissions, expiry and reviewed versions. Use an authorised availability check for the proposed slot; stop if unavailable or inconclusive.
  2. Change the visit’s start and end using a conditional write that requires version 17 and the reviewed state. Record the confirmed result and resulting version.
  3. Verify the saved visit target. Before the task write, require the visit to remain at its confirmed target version and the task to remain at version 8 in its reviewed state. Enforce these dependencies transactionally or with an equivalent execution-layer guard.
  4. Change only the task due time using a conditional write against its reviewed version and state. Record the confirmed result and resulting version.
  5. Verify and report each outcome separately. A failed condition stops remaining execution.

No-ops and stop conditions

  • Initial no-ops: none. Both reviewed baselines differ from their targets.
  • Reconciliation no-op: if a confirmed write under AC-042 already produced the exact target, and the record still matches its recorded resulting version and protected values, do not repeat that write. Remaining steps still require their own checks.
  • Different version: stop unless it is the recorded result of this contract’s confirmed write. A coincidentally matching target is not an exception.
  • Missing or closed task, changed owner, unavailable slot, expired approval or lost permission: stop. Do not reopen, reassign, replace or choose another slot.
  • Uncertain result: perform permitted reconciliation reads. Do not blindly retry or infer failure from a timeout. Stop if attribution or state remains uncertain.
  • Excluded: new records, reminder changes, cancellations, price changes, unrelated records, customer messages and automatic rollback.

Notification boundary

Sending permission: not granted. Only after both internal changes are confirmed may the assistant present this hypothetical text in the approval preview, without sending it or saving it elsewhere:

Your service visit has been moved to Thursday 15 October, 13:00–15:00, Europe/London. Please reply if you need to discuss this time.

A separate approval must bind the customer destination, channel, exact message and verified visit state. Any later schedule change invalidates that notification preview.

4. Protect the gap between checking and writing

A read followed by an unconditional write cannot guarantee protection against concurrent changes. The task might be open when checked and closed by a colleague before the assistant writes its new deadline.

Recommend conditional writes tied to the reviewed version, or equivalent transactional enforcement where available. The execution layer should reject the write if the required version or state no longer matches. A failed condition means stop, not fetch a newer version and retry under the old approval.

The dependency between records matters too. A conditional task write protects the task, but does not by itself prove that the visit still has its approved schedule. If that dependency must remain true at the moment of writing, the execution layer needs a transaction or equivalent guard covering it.

These are design requirements, not claims about an available Alactic feature. If the required checks cannot be enforced, do not describe the workflow as protected against concurrent changes. Keep it non-writing or redesign the operation before authorising execution.

5. Report partial completion without inventing recovery powers

Consider this hypothetical execution: the visit write succeeds and returns version 18. A colleague then closes the task, moving it from version 8 to version 9. The attempted conditional task update fails.

The correct report is specific: “Visit SV-1842 changed and verified at version 18. Task T-662 was not updated because its version changed. No customer message was sent.” The sequence is partially complete, not successful overall.

Do not reopen the task or create a replacement. Do not automatically restore the visit’s old time: rollback is another write, and the earlier slot may no longer be suitable or available.

A recovery preview should show the current records and request approval only for the remaining decision. For example, a coordinator might choose to leave the closed task untouched. That is a new decision, not an interpretation the assistant should supply.

Likewise, a timeout is not proof of failure. Reconcile through authorised reads and available execution evidence. If the result cannot be attributed confidently, report uncertainty and stop rather than risking a duplicate action.

6. Approve customer contact separately

A notification creates an external commitment. Its preview should show the resolved recipient, intended channel, exact text and verified schedule—not simply a “Notify customer?” checkbox.

If WhatsApp is selected, internal authorisation is only one requirement. Recipient permission matters and opt-outs must be honoured. Under the WhatsApp Business Messaging Policy, approved templates are used to initiate Platform conversations and outside the 24-hour customer-service window. That window opens or resets with a user message. Check the current policy for precise requirements.

Keep message preparation, template review and actual delivery as separate states. Template approval does not guarantee delivery. Automation also needs a clear human escalation path.

A useful report distinguishes draft prepared, sending approved, submission attempted and delivery confirmed where evidence exists. An approved draft is not evidence that the customer was notified.

7. Make the preview and execution evidence agree

The approver should see the same bounded plan the execution layer receives. A narrow summary over broader executable instructions is misleading, even if the summary sounds reasonable.

Retain the contract version, approver, approval time, expiry, reviewed record versions, allowed changes, permission checks, conditional-write outcomes and confirmed resulting versions. Record no-ops with their qualifying evidence, not simply “skipped”. Link any recovery approval to the stopped contract without silently extending its scope.

This evidence answers concrete questions: Which write was authorised? Which condition failed? Was a matching target attributable to this attempt? Did the assistant stop before contacting the customer?

Alactic offers CRM and WhatsApp business communications products; ACID supports business-assistant workflows. Those roles do not establish that this contract’s controls exist in every product or interface. Check the workspace and current plan for availability, and verify enforcement separately.

8. Test enforceability before a supervised pilot

Begin with non-writing tests. Use hypothetical cases covering unchanged baselines, a record already reviewed at its target, an unexplained version change, a task closed between check and write, a lost response, expired approval and a notification added after approval.

Write the expected next action before each test. Inspect actual permission checks, conditional-write results, no-ops and stop reports. Test both same-record races and changes to a prerequisite record.

A supervised live pilot is appropriate only after verifying that the execution layer enforces the approved plan, per-request permissions, stop conditions and concurrent-change handling. Supervision alone does not replace those controls.

Evaluate out-of-contract write attempts, correct stops and confirmed writes traceable to valid approval. A high completion rate can conceal weak boundaries. Start by turning one real request into a filled contract; any step that cannot be bounded or enforced should remain outside execution authority.

AI action safetyAuthorisationBusiness operationsHuman oversight

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