# SOX controls for AI agents: an ITGC map

> SOX controls for AI agents map to the ITGCs you already run: access, deprovisioning, segregation of duties, approval and an audit trail.

**TL;DR** SOX controls for AI agents are the same IT general controls you already run: logical access, provisioning and deprovisioning, segregation of duties, change approval and an audit trail. Elaichi maps each one to a mechanism: a role per person, per-person connections, restrictions on connectors and tools, locked-in argument values, and an audit log with a free Auditor seat. This is not legal advice, and no control here establishes a certification.

## The situation

Your controller asks Claude which invoices are unpaid. A week later somebody asks it to post a journal entry. The second request is a change to a financial system, made by software, under a person's name. Your external auditor will want to know who that person was, what they were allowed to do, who approved the change, and where the record is.

SOX controls for AI agents are not a new control family. They are the IT general controls you already run, applied to a caller that happens to be an AI client. This post maps each ITGC question to a mechanism in Elaichi, which is a governed MCP control plane. None of it is legal advice, and nothing here establishes a certification.

Read the primary sources directly. The SEC's [final rule for Section 404](https://www.sec.gov/rule-release/33-8238) sets management's assessment duty. The PCAOB's [AS 2201](https://pcaobus.org/oversight/standards/auditing-standards/details/AS2201) governs the audit of internal control over financial reporting.

## What do SOX controls for AI agents actually cover?

They cover the same five areas as any other ITGC review: logical access, provisioning and deprovisioning, segregation of duties, approval before risky changes, and an evidence trail. What changes is the caller.

An AI client is [not an identity of its own](/blog/non-human-identity-ai-agents/) in Elaichi. Each person connects their own client and approves their own grant. Every call made with that grant acts as the person who approved it, in the organization they picked. Their permissions are looked up on each request rather than stored in the token. So the control question is never "what can the AI do", it is "what can this employee do, and did the AI stay inside it".

That framing matters for scoping. If your accounting system is in scope, the AI path into it is in scope too. If the assistant only reads a marketing dashboard, it is not.

## Logical access: who reaches the accounting system

Access comes from three separate layers, and an auditor will ask about each. Keeping them apart is the difference between a clean walkthrough and an hour of confusion.

Permissions say what a role lets a member do. A member holds exactly one role in an organization, so each role is meant to be a complete persona. To combine two personas, an admin authors a custom role, which Gold and Black include.

Sharing says who may use a given connection, toolbox or template. A member sees only what they own or what has been explicitly shared with them. No organization permission widens that listing, for an owner or an admin.

Restrictions say which connectors and tools a role or a member may reach. In Elaichi, restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything.

For a finance rollout, that usually means a block rule on the roles outside finance naming the accounting connector whole, and tighter rules inside finance naming the tools that move money. On Elaichi's buildium connector, for example, the tools that create payments, withdrawals and refunds include `create_a_buildium_bill_payment`, `create_a_buildium_bankaccount_withdrawal` and `create_a_buildium_lease_refund`. Those are named individually in a rule.

One trap deserves plain wording. An allow rule turns on the allowlist for its layer just by existing, whatever it names. An allow rule that names nothing blocks every connector and tool for its target. If you reach for an approved-apps list, write it as allow rules naming whole connectors, and include every app the role still needs.

## Provisioning: per-person connections, not a shared service account

The cleanest answer to "whose access was used" is that each person connected their own account. In Elaichi, a connection with no sharing grants is private to its owner, and a shared connection runs every caller's call on the connection's own bound account.

Get that second half right in a financial system. A connection shared at the use level runs as its single owner, whoever is calling. So if your accounting connector is shared across the finance team, every tool call reaches the app as the person who connected it, and the app's own permission model sees one identity.

Where a control needs per-person permissions inside the app, the tools must run on each person's own connections: their All tools toolbox, a toolbox built on their own connections, or a template each person stamps while picking their own connection. Sharing a template at the use level lets each teammate stamp it and pick their own account for each app. That is the mechanic covered in [sharing one setup across a team](/blog/share-one-ai-tool-setup-across-a-team/).

Some financial systems decide this for you. Intuit's UK help page says only the primary admin and Company Admin can connect and manage apps in QuickBooks Online ([Intuit help](https://quickbooks.intuit.com/learn-support/en-uk/help-article/mobile-apps/connect-app/L1L5cXGvI_GB_en_GB), checked October 2026). Where that rule applies, a QuickBooks connection is authorized by an admin, and every call through it uses that authorization. Say so in your control narrative rather than implying per-person identity you do not have.

## Deprovisioning: what stops, and how fast

Auditors sample terminations and ask when access ended. Elaichi has two different speeds here, and conflating them is the most common error in a narrative.

Removing a member revokes every live MCP OAuth grant they hold in that organization, and suspending a member does the same. Because grants are re-read on every request, the member's AI clients fail on their next request. Reactivating the member does not restore the grants; they have to consent again. In Elaichi, revoking a share or disconnecting an account takes effect on the caller's next call.

Role, team membership, restriction and access-grant changes are different. Those reach every surface within about two minutes. If your control says "access changes are effective immediately", tighten the wording. Say removal and suspension stop clients at their next request. Say a role or restriction change takes effect within about two minutes.

SCIM deprovisioning always suspends a member; it never deletes the member row. Sending active:true sets them back to active, but it does not restore the grants that suspension revoked. That is the right behavior for an auditor, and the narrative should say so.

Removing a member outright is a separate admin action with its own preflight. It lists the connections they own, their toolboxes and templates, and the toolbox entries anywhere in the organization that rely on them. [Offboarding AI access](/blog/offboarding-when-the-agent-holds-access/) walks the decisions.

## Segregation of duties when an assistant does both halves

Segregation of duties breaks when one identity can both create and approve. An AI client inherits the person's role, so the first test is whether that person already violated the rule. If a controller can create a bill and pay it in the accounting system, the assistant can too.

What an access layer adds is a second cut, below the app's own roles. Restrictions name individual tools, so a role can reach an app's read tools and its create tools while the tools that release payment are blocked for it. Block rules match a tool by name or by the operation it performs, so renaming a tool cannot slip it past a block.

The second cut is locked-in argument values, which Elaichi calls frozen parameters. An entry in a toolbox can carry argument values a caller cannot override, and frozen values win over the caller's arguments at execution. [Locking a tool argument](/blog/frozen-parameters-wire-transfer-receiver/) covers the payee case.

Two honest limits belong in the narrative. The AI can see which keys are frozen, and often the short values, because Elaichi puts a note in the tool's description. It cannot change them. And a freeze holds only on calls that run through the entry carrying it, so anyone who can use the connection directly has the same tool unfrozen. Close that path by not sharing the connection, not by adding a restriction, because a restriction would block the frozen entry too.

## Approval before a risky write

Over MCP, the approval moment is Elaichi's consent screen. The scopes a person grants a named client there are the standing approval for that client's calls, because over MCP there is no trusted Elaichi prompt at call time.

That has a specific consequence your auditor should hear. The "Use your connected apps" checkbox lets a client run the person's connected tools, writes and deletes included. Unticking "Make changes" does not make a connected app read-only; that box governs Elaichi's own write operations. To hold a client to reads, pick toolboxes of read tools at consent, or block the write and delete tools with a restriction.

A per-call confirmation a person sees in Claude or ChatGPT is that client's own prompt, not Elaichi's. Claude documents three settings for connector tool permissions, Always allow, Needs approval and Blocked ([Anthropic support](https://support.claude.com/en/articles/11176164-use-connectors-to-extend-claude-s-capabilities), checked October 2026). Useful, and outside your control plane.

Where you need a person in the loop before a payment leaves, that is a workflow approval step, which comes with the Black plan. Payment approvals go further. A payment step declares the amount, currency and payee, and the payment policy sets, per currency, the amounts above which a payment needs one or two approvals. The person who started the run never counts as an approver, and no AI client can answer one. [AI spend controls](/blog/elaichi-spend-controls/) covers the setup.

## The audit trail an auditor can sample

Every connected-tool call that reaches execution writes one row. It records the acting user, the toolbox the call went through, the tool's advertised and catalog names, the connector, the connection the call reached, and the tool's classification. It also records whether approval was required and how it was given, whether a person edited the arguments, the surface, and the MCP client's id when the surface is mcp.

Four things are not in it, and saying so up front saves a follow-up. Calls refused before execution write no row: a tool a restriction withholds, a missing scope, an unknown tool name, a rate limit. The row records no argument values except the one path argument that names the object. There is no duration on a connected-tool row. And a failed call records a fixed error code, not the third party's message.

Elaichi keeps 90 days of audit history. Where your policy requires keeping records longer than the audit log's retention, forward it: logging destinations come with the Black plan, and Datadog is the destination that delivers. [Audit log retention](/blog/audit-log-retention-ai-actions/) works through the gap.

For the reviewer themselves, the Auditor role is a free seat. It holds view permissions only, including audit:view, and no create, share, manage, override or tool:execute permission. Two of its permissions, connection:view and template:view, are reserved and grant nothing, so an Auditor does not see other members' connections or templates. Set that expectation before the walkthrough. [The read-only Auditor setup](/blog/auditor-seat-for-compliance-reviewers/) has the details.

## Where this is not the answer

If your financial systems are reached by one person on one laptop, an access layer is overhead. Connect the app's own MCP server, keep the audit trail the vendor gives you, and revisit when a second person asks for access.

If the assistant never touches an in-scope system, leave it out of the SOX narrative. Scoping discipline is a control in itself.

And one claim this product cannot make: Elaichi's MCP endpoint has no prompt-injection defense of its own. The endpoint receives a tool name and arguments, never the person's prompt, so it has nothing to judge a call against. That defense belongs to the client. Put it in the risk section honestly rather than letting an auditor find it.

If you are starting the map, the [MCP governance overview](/blog/mcp-governance/) sets out the layers, and the [connector catalog](/connectors/) shows which financial systems have a connector today.

## FAQ

### Does an AI assistant need its own identity for SOX purposes?

In Elaichi, no. Each person connects their own AI client and approves their own OAuth grant, and every call made with that grant acts as the person who approved it, in the organization they picked. Their permissions are looked up on each request rather than stored in the token. So the audit question is which employee the call acted as, not what a separate machine account was allowed to do. If a connection is shared across a team, the call still reaches the third-party app as that connection's owner, and a control narrative should state that plainly.

### How quickly does access end when someone is terminated?

In Elaichi, removing a member revokes every live MCP OAuth grant they hold in that organization, and suspending a member does the same. Because grants are re-read on every request, their AI clients fail on their next call. Reactivating the member does not restore the grants; they have to consent again. Role, team membership and restriction changes are slower: those reach every surface within about two minutes. A control narrative should state both speeds rather than claiming all access changes are immediate.

### What does Elaichi's audit log record for each AI tool call?

Each connected-tool call that reaches execution writes one row recording the acting user, the toolbox the call went through, the tool's advertised and catalog names, the connector, the connection reached, the tool's classification, whether approval was required and how it was given, whether arguments were edited, the surface the call came from, and the MCP client's id for MCP calls. It records no argument values except the one path argument naming the object, and no duration. Calls refused before execution, such as a restricted tool or a missing scope, write no row.

### Can a reviewer get read-only access without taking a paid seat?

Yes. Elaichi's Auditor role is a free seat, and the console marks it Free in the roles list and the invite dialog. It holds view permissions only, including audit:view, and no create, share, manage, override or tool:execute permission. It opens billing details, the connector catalog, restrictions, API token metadata, SSO and SCIM settings, logging and notification destinations, and the audit log. It does not by itself show other members' connections, templates or toolboxes, because access to those resolves from ownership or an explicit share.

### Can unticking a consent checkbox make an AI client read-only in a connected app?

No. In Elaichi, the "Use your connected apps" scope lets a client run the person's connected tools, including writes and deletes. The "Make changes" box governs Elaichi's own write operations, so unticking it does not make a connected app read-only, and "Delete things" covers only Elaichi's own deletes. To hold a client to reads, pick toolboxes of read-only tools on the consent screen, or write a restriction blocking the connector's write and delete tools for that role.

## Read next

- [NIST AI RMF and AI agents: evidence by function](/blog/nist-ai-rmf-and-ai-agents/) — A function-by-function map of NIST AI RMF and AI agents that call tools in company apps, and the records an access layer produces for each.
- [MCP role-based access control and audit logs](/blog/mcp-role-based-access-control-and-audit-logs/) — MCP role-based access control is two decisions: a role says what a member may do, and a restriction says which tools that role can reach.
- [ISO 42001 and AI agents: evidence](/blog/iso-42001-ai-agents/) — ISO 42001 and AI agents meet at runtime records: who ran which tool, on which account, from which AI client, and what an access layer cannot supply.
