Back to all articlesAI action safety

Limit Which Fields an AI Assistant May Change

Alactic Editorial9 min read

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

An assistant asked to update an enquiry’s preferred callback time should not also change its owner, rewrite its notes, or save a complete copy of the record. The safest boundary is an action-specific write contract: identify the record, name the fields the action may change, bind approval to their proposed values, and reject any payload that exceeds that scope.

Enforce that contract where the write is executed, not only in the assistant’s instructions. A helpful-sounding proposal can still contain an unauthorised change. Approval of a callback-time patch must never become approval to replace the entire enquiry.

The worked example below provides a filled allowed-change register, a narrow request shape, and rejection rules that an operations lead and an implementation team can review together.

1. Make the permission smaller than the record

A record may contain information the assistant needs to read but has no reason to edit. Reading the enquiry’s owner, contact details, and status can help the assistant understand the task. It does not give the assistant permission to write those values back.

Define the action as a specific business change, such as update_preferred_callback, rather than a general instruction to “save enquiry.” Its write boundary should answer:

  • Which enquiry is this action authorised to affect?
  • Which exact field paths may appear in its change payload?
  • Which proposed values has the approver accepted?
  • What record state must still hold when the action executes?
  • Which related actions, such as assigning work or sending a message, remain outside scope?

An allowlist is easier to reason about than an expanding list of forbidden fields. If the action allows only a callback timestamp, a newly introduced field is not writable by default. The implementation must not assume that an unfamiliar field is harmless.

This follows the least-privilege, deny-by-default approach in OWASP’s authorization guidance, which also recommends checking permissions on every request. Those are design recommendations, not evidence that a particular product already implements this control.

2. Separate the patch, its context, and the approval

Three pieces of information belong in different conceptual buckets. The target identifies the record. The patch contains only the requested business changes. The control context carries information such as the expected record revision and the approval reference.

Mixing them creates ambiguity. A record identifier should select the target, not become an editable property. An approval reference should be checked against a trusted approval record, not treated as proof merely because the assistant supplied it.

Fictional worked example: an authorised staff member approves moving enquiry ENQ-482 from 16 September 2026 at 14:00 to 17 September 2026 at 10:30, using the enquiry’s existing Europe/London callback timezone. The enquiry is currently at revision 27. The approval covers that time change only. All identifiers, values, and payloads in this worked example are hypothetical.

A proposed request could have this conceptual shape. This is a design illustration, not a product endpoint or an integration specification:

{
  "action": "update_preferred_callback",
  "target": {
    "enquiry_id": "ENQ-482"
  },
  "expected_revision": 27,
  "approval_reference": "APR-615",
  "changes": {
    "preferred_callback_at": "2026-09-17T10:30:00+01:00"
  }
}

The executor should resolve the approval reference and confirm that it covers this action, this target, and this exact proposed value. Possessing an enquiry ID is not sufficient authority to change it; OWASP’s object-level authorization guidance makes that distinction explicit.

3. Use a filled allowed-change register

The following is a table-style register expressed as field rows so it can be copied into an action specification. Every entry belongs to the fictional example above. “Protected” means unavailable to this action, not necessarily unavailable to every authorised workflow.

Permitted business change

  • Field: changes.preferred_callback_at
    Current value: 2026-09-16T14:00:00+01:00
    Approved value: 2026-09-17T10:30:00+01:00
    Rule: Required and writable for this action, but only with the approved value.
    Reject when: Missing, null, invalid, or different from the approved timestamp.

Protected business fields

  • Field: callback_timezone
    Current value: Europe/London
    Rule: Read for interpretation; do not include in the patch.
    Reject when: The proposed changes contain this field, even with its existing value. A timezone change requires separate scope.
  • Field: owner_id
    Current value: USR-18
    Rule: Protected.
    Reject when: The assistant proposes an owner assignment or includes the existing owner in the patch.
  • Field: status
    Current value: open
    Rule: Protected.
    Reject when: The payload changes status to callback_scheduled. That may sound related, but it was not approved.
  • Fields: contact.phone, notes, and marketing_permission
    Current values: Existing contact number, existing enquiry notes, and existing permission state.
    Rule: Protected in full.
    Reject when: Any appears in the change payload, including rewritten notes, normalised contact details, or a null value.

Control entries, not editable record fields

  • Entry: target.enquiry_id
    Accepted value: ENQ-482
    Rule: Must match the authorised target.
    Reject when: It names another enquiry or the requester lacks authority over the target.
  • Entry: expected_revision
    Accepted value: 27
    Rule: Compare with current state before committing.
    Reject when: The revision is missing or stale.
  • Entry: approval_reference
    Accepted value: APR-615
    Rule: Resolve and verify against the approved action.
    Reject when: It is unknown, withdrawn, already consumed where approval is single-use, or bound to a different proposal.

Unexpected payload entries

  • Entry: changes.priority = high
    Decision: Reject the whole request.
    Reason: A business field outside the allowlist was included.
  • Entry: changes.contact = { ... }
    Decision: Reject the whole request.
    Reason: A nested object could replace protected contact information.
  • Entry: record = { ... }
    Decision: Reject the whole request.
    Reason: A complete-record representation is not the approved patch.
  • Entry: send_confirmation = true
    Decision: Reject the whole request.
    Reason: Sending a communication is a separate action, not part of updating a preference.

This strict register deliberately rejects protected fields even when their supplied values appear unchanged. That keeps the request contract narrow and prevents a stale record copy from quietly becoming write authority.

4. Check the complete payload before applying anything

The execution boundary should validate both the request envelope and the contents of changes. Checking only the visible callback field leaves room for extra top-level entries, nested writes, or alternate representations of the same operation.

  1. Validate the request shape. Reject unknown entries and ambiguous structures, including duplicate keys where the parser can detect them. Do not allow different components to interpret the same payload differently.
  2. Authorise the target and action. Confirm permission for this enquiry and this operation at execution time.
  3. Compare writable paths with the allowlist. Validate exact paths, not just broad parent objects such as contact.
  4. Check values against approval. A field being writable does not authorise every possible value for it.
  5. Check the current revision and relevant context. The timezone used to interpret the approved time must still be the expected one.
  6. Commit atomically. Either the approved patch is applied in full or no business fields change.

Do not silently strip unapproved fields and execute the rest. That would make a rejected proposal appear successful and conceal the assistant’s scope error. Return a clear rejection identifying the offending paths and stating that no change was committed. The assistant can then prepare a corrected proposal for the appropriate approval process.

5. Prevent a narrow patch from becoming a full replacement

A full-record save can overwrite fields that are absent from the user’s instruction. It can also restore stale values that another person changed after the assistant read the enquiry. Even a payload containing mostly unchanged information can therefore cause an unauthorised write.

Do not rely on an operation being labelled “patch.” Check its actual behaviour. Nested object replacement, default values, null handling, and omitted-field handling all matter. A callback action should not accept removal operations or interpret null as permission to clear a field unless that exact change has been separately defined and approved.

The preferred design is a dedicated narrow update that writes only the permitted field and checks the expected revision. If the underlying system supports only complete-record replacement, the assistant should not supply the replacement document. A trusted component would need to construct it from current state, apply only the authorised change, and verify that no protected values differ.

That fallback still needs a conditional, atomic commit to avoid overwriting a concurrent edit. If the system cannot provide those guarantees, route the task to a controlled manual process rather than treating the replacement as equivalent to the approved patch.

6. Define side effects before they surprise the approver

A field restriction is incomplete if updating the permitted field triggers unrelated business changes. Before enabling the action, identify whether changing the callback preference also creates a task, assigns an owner, changes a status, or sends a communication.

For this fictional example, the allowed business outcome is only the changed callback timestamp. A system-managed revision increment and an audit event may be expected execution metadata; they are not fields the assistant may choose. Document them separately from assistant-supplied changes.

If an existing workflow changes business fields or starts communication, either exclude it from this action or expand the proposed action visibly and obtain the necessary authorisation. Do not describe a bundled workflow as a time-only edit.

Strict boundaries introduce friction: a genuinely useful owner reassignment needs another action, and an unfamiliar field causes rejection rather than best-effort execution. The trade-off is intentional. Each rejection makes the boundary observable instead of allowing the assistant to decide which extra changes are acceptable.

7. Recover without widening the original permission

Different failures need different recovery paths. An unexpected field calls for a corrected proposal. A changed record calls for a fresh read. An uncertain execution result calls for checking what actually committed.

  • Extra field rejected: Report the field path and scope reason. Do not repeatedly retry the same payload or drop the field silently.
  • Revision conflict: Read the current enquiry and re-evaluate the proposal. In this design, a changed revision requires renewed approval rather than automatically carrying the old approval forward.
  • Unclear callback time: Ask for clarification before creating an executable proposal. Do not infer a new timezone as part of the write.
  • Execution outcome unknown: Check the recorded action outcome and current field value before retrying. A timeout is not evidence that nothing changed.
  • Wrong value committed: Prepare a separately authorised correction against current state. Do not restore the entire earlier record, which could erase intervening work.

Keep an audit trail sufficient to connect the requested change, approval, validation result, and committed field difference. Avoid copying unrelated contact data into that trail merely because it was available to the assistant.

8. Test the boundary with visible pass conditions

Start with one action and a controlled test record. For the hypothetical callback action, submit the valid proposal, then vary one condition at a time: add an owner, include unchanged notes, supply a nested contact object, change the approved timestamp, use a stale revision, target another enquiry, omit the required value, and submit a complete record.

For each rejected case, inspect the stored record rather than relying only on the assistant’s response. The pass condition is explicit: no business field changed, the rejection identifies the relevant scope problem, and no related business action ran. For the valid case, confirm that only the approved callback value changed, apart from documented system metadata.

A useful next action is to fill this register for one live workflow before enabling assistant writes. Measure accepted requests, scope rejections, revision conflicts, and verified out-of-scope changes separately. The boundary is working when the stored outcome matches the approved patch—not merely when the assistant reports success.

AI action safetyField permissionsCRM workflowsApproval controls

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