Audit compliance of AI agents' autonomous decisions on employee devices: inventory, per-action evidence, policy before execution, and framework mapping.
Audit compliance for AI agents' autonomous decisions on employee devices means being able to prove, action by action, what an agent did on a laptop, which employee it acted for, which policy allowed or stopped it, and that the record lives somewhere neither the agent nor the employee can edit. Without that record, the decision is unauditable.
That bar is new for most security, compliance and internal-audit teams. Agents on laptops act with the employee's own access, often outside any system you already log, and an auditor who asks to see the control usually gets activity logs instead of evidence that a control operated. Our guide to auditing AI systems and autonomous agents covers the full audit lifecycle. This page goes one level deeper on the hardest part of it, the laptop, and answers five questions: which agents are there, how to find them, what each record must hold, how to enforce and prove policy, and how the evidence maps to SOC 2, ISO/IEC 42001, the EU AI Act and employee privacy law.
Four kinds of AI agents run on employee devices today: desktop assistants, IDE and CLI coding agents, browser agents, and local Model Context Protocol (MCP) servers. They're harder to audit than server-side agents because they act with the employee's own credentials, skip the network chokepoints you already log, and keep whatever records they write on the laptop itself.
The type matters less than three questions an auditor will ask of each one: what can it reach, where do its own records end up, and what can't you see?
| Agent type | What it can reach | Where its own records live | The auditor's blind spot |
|---|---|---|---|
| Desktop assistants | Local files, other applications, and SaaS tools through the employee's signed-in sessions | App storage on the laptop or the vendor's cloud console; varies by product | Actions inside other apps look like the employee did them |
| IDE and CLI coding agents (Claude Code, Cursor, Codex CLI and similar) | The shell, the repository, package managers, and credential files in the home directory | On the laptop by default; Claude Code can export telemetry when an administrator configures it | Settings and instructions arrive with every cloned repository |
| Browser agents | Logged-in web sessions, forms, purchases and approvals | Browser or extension storage; rarely anywhere central | Server-side logs show the employee's session, not the agent inside it |
| Local MCP servers | Whatever they expose to any connected agent: files, databases, stored SaaS tokens | Standard error output, which the client may capture, forward or ignore | Often no central record that the server exists at all |
Server-side agents inherit the audit plumbing you already run. Agents on a laptop don't, for five reasons:
Local MCP servers deserve their own review, because one server can hand every connected agent the same reach. Our guide to MCP compliance for regulated industries covers how MCP servers fit sector rules such as financial-services and healthcare obligations, and which controls auditors in those sectors look for.
To discover and inventory AI agents on employee devices, combine four signals: MDM inventory for what is installed, EDR telemetry for what runs, agent configuration files for how each agent is set up, and decision records for what agents actually did. No single signal is enough, so reconcile them on a schedule and treat the gaps as findings.
Mobile device management (MDM) is the channel that installs apps and configuration profiles on managed laptops. Endpoint detection and response (EDR) records process, file and network activity. Both were built for software and people rather than agents, which is why the agent-specific signals carry most of the weight.
Each agent leaves files and processes you can collect through MDM scripts or EDR queries. Claude Code is the best-documented example, so it anchors the table; look for the equivalent files for every other agent you allow.
| Agent or signal | Where to look | What it tells you | What it misses |
|---|---|---|---|
| Claude Code, user and project configuration | ~/.claude/settings.json; .claude/settings.json and .claude/settings.local.json in each repository; ~/.claude.json, which holds MCP server configurations | Installed, configured, and which MCP servers it can reach | Whether and how it was used |
| Claude Code, managed policy | /Library/Application Support/ClaudeCode/managed-settings.json and managed-mcp.json, or a configuration profile for the com.anthropic.claudecode domain | Whether the device receives your policy | Drift: confirm what applies with /status or claude doctor, which show the managed source in effect |
| Other coding agents and IDE extensions | Application and extension inventories from MDM; agent configuration folders in home directories | Presence and version | Configuration detail varies by product; nothing about usage |
| Local MCP servers | EDR process trees showing an agent starting a server as a child process; listeners on localhost | A server is running, and which agent launched it | What the server was asked to do |
| Browser agents and AI extensions | Managed browser extension inventories | Presence in managed browser profiles | Personal profiles and unmanaged browsers |
Admins can also restrict which MCP servers Claude Code may use to a managed list with allowManagedMcpServersOnly, which turns the MCP inventory from a discovery exercise into an allowlist you maintain.
Plot the four signals on two questions: does it know which agent acted and how it was configured, and does it see what the agent did?
Keep one row per agent per device, with enough to assign an owner and spot drift:
Compare the signals against each other on a schedule. An agent that shows up in configuration fingerprints but sends no decision records is running off the governed path. A device that sends decision records but has dropped out of MDM may be enforcing stale policy. Each mismatch is a finding with an owner and a due date.
Watch for personal accounts, too. An employee signed into a personal subscription of a sanctioned agent looks sanctioned in the app inventory. Telemetry that carries an organization identifier, as Claude Code's does, helps separate work use from personal use. For discovery beyond the laptop, our guide to shadow AI covers network and SaaS signals and how to move unsanctioned tools onto a governed path instead of simply banning them.
A usable AI agent audit trail on the endpoint has one record per action, written by something other than the agent, attributed to the agent and the accountable employee, and shipped to a store off the laptop. Each record carries the policy verdict and the rule behind it, so an auditor can test the control instead of reading activity.
The general fields every AI audit trail needs are covered in our AI audit guide. On a laptop, the record has to travel further and survive more, so the flow below is the shape every design should follow, whoever builds it.
The fields below are the ones a laptop adds or changes. Device, decision source, policy version, sequence number and receipt time are what turn an activity log into evidence an auditor can test.
| Field | What it answers for the auditor | Endpoint-specific note |
|---|---|---|
| Agent and session | Which agent acted, in which run | Agent name, version and session identifier |
| Accountable employee | Who the agent acted for | A directory identity, not a local username |
| Device | Where it happened | Managed device identifier and health at decision time |
| Action | What was attempted | Tool, command or file path, and target; redacted or hashed where your privacy assessment requires |
| Verdict | What the control decided | Allow, flag, block or escalate |
| Decision source and rule | Why | Rule identifier, policy version, and whether a managed rule, a hook or a person decided |
| Approver | Who signed off an escalation | Named human and time of approval |
| Outcome | What happened next | Success or failure, and duration |
| Time and sequence | When, and whether anything is missing | Device time, server receipt time, and a per-device sequence number |
| Integrity | Whether the record was altered | Signature created on the device and verified on receipt |
Attribution to both parties is an identity problem before it is a logging problem. The agent needs an identity of its own, distinct from the employee's, and the record needs a verifiable link from that identity to the person it acted for. Our guide to non-human identity explains how agent identities are issued, scoped and retired alongside service accounts and workloads.
Some agents already emit useful events. Claude Code can export OpenTelemetry data: a claude_code.tool_decision event records whether a tool call was accepted or rejected and whether configuration, a hook or the user made that call, and a claude_code.tool_result event records the tool, success, duration and MCP server scope. Events carry session, user, email and organization identifiers. An administrator can set the export endpoint in managed settings, and repository-level OpenTelemetry variables are ignored.
Anthropic's documentation includes two caveats that matter for audit. A developer can still disable a signal unless the exporter itself is set in managed settings, and the docs don't state that managed settings can force the content switches off.
That's good evidence from one vendor's agent. It isn't a fleet audit trail: it covers one tool, its verdicts come from settings you have to lock down separately, and it says nothing about the other agents on the same laptop.
Agent records are employee data. They name a person, and commands and file paths can reveal what that person is working on. Design for that from the first field:
OTEL_LOG_USER_PROMPTS=1 is set, and tool inputs such as commands only with OTEL_LOG_TOOL_DETAILS=1.Laptops sleep, travel and lose connectivity. The evidence has to survive that:
Describe integrity in terms an auditor can check, not adjectives:
Enforcing policy before execution means checking each proposed agent action against your rules on the device and allowing, flagging, blocking or escalating it before it runs. You prove it with the records the check leaves behind: every verdict, including every block, names the rule that fired, so an auditor can replay a denied action and find its record.
An activity log tells you an agent deleted a directory. It doesn't tell you a control existed, whether it fired, or whether the deletion was in policy. Auditors test controls, and a SOC 2 Type II report covers whether controls operated effectively over a period. That makes the block record, the evidence of an action that never happened, some of the strongest material you can hand over. To maintain auditability and compliance for AI autonomous decisions, the denial has to be as visible as the success.
| Verdict | What happens | What it proves to an auditor |
|---|---|---|
| Allow | The action runs and a record is kept | The action matched policy, under a named rule and version, at that moment |
| Flag | The action runs and is marked for review | Detection works and someone follows up; the review notes become evidence too |
| Block | The action never runs and a record is kept | The preventive control operated |
| Escalate | The action waits for a named human to approve or deny it | Human oversight happened, with the approver and the time on record |
Escalation design is a topic of its own. Our guide to human-in-the-loop AI covers which agent actions should stop and ask, and how to keep approvals from turning into rubber stamps.
Every record should say what decided: a managed rule, a local rule, a hook, or a person clicking approve. Claude Code shows the pattern. Its tool_decision event carries a source field that separates configuration, hooks and user decisions, and a rejected call appears as a decision event rather than a tool result. Its managed settings can make managed policy the only source of permission rules and hooks (allowManagedPermissionRulesOnly, allowManagedHooksOnly), which removes the question of whether a developer's local rule let the action through.
Anthropic's docs also note that a user with local administrator rights can edit the managed settings file. Redeploy it through MDM on a schedule and alert on drift, so the policy version stamped on each record is one you can stand behind.
Blocking on day one breaks builds and teaches developers to route around the control. Run observe-only first to baseline what agents actually do, write rules from that baseline, flag before you block, and record every policy change with who approved it. The change history is evidence too: it shows the control was designed, reviewed and tuned, not switched on once and forgotten.
An auditor trusts a control that states its limits more than one that claims to have none.
None of these frameworks names AI agents on employee laptops. SOC 2 and ISO/IEC 42001 reach them through reasonable interpretation, the EU AI Act's logging duties attach only where the agent use is a high-risk AI system, and privacy law constrains what you may log about employees. Label each mapping honestly: stated law, reasonable interpretation, or no authority.
The table sorts AI agent compliance evidence by how firmly each source asks for it. Put the same label in your control narrative; auditors and regulators respond better to an honest "this is our interpretation" than to a claim of coverage the text doesn't support.
| Source | What it asks of endpoint agent evidence | Status |
|---|---|---|
| EU AI Act, Article 12 | Automatic recording of events over the system's lifetime, to support traceability | Stated law for high-risk AI systems. Applying it to an ordinary coding agent: reasonable interpretation |
| EU AI Act, Article 26(6) | Deployers keep the logs under their control for at least six months, unless other law provides otherwise | Stated law for deployers of high-risk systems. As a default for every agent: no authority |
| EU AI Act, Article 26(7) | Employers inform workers' representatives and affected workers before using a high-risk AI system at the workplace | Stated law for high-risk systems; good practice for any agent whose records name employees |
| SOC 2 Trust Services Criteria | Evidence that logical access and monitoring controls operated across the report period | Reasonable interpretation: the criteria don't name agents |
| ISO/IEC 42001 | Documented, operating controls over the AI systems in your management system | Reasonable interpretation: it is a management-system standard, so the endpoint evidence is yours to define |
| GDPR, Article 5 | Collect only what the purpose needs and keep it no longer than needed | Stated law; how much agent content to keep is a judgment you document |
| GDPR, Article 35 | A data protection impact assessment where processing is likely to result in a high risk | Stated law; whether agent logging triggers it: reasonable interpretation (often yes) |
| GDPR, Article 88 and national law | Member-state rules for employee data, including monitoring systems at work; works council rights | Stated law, varying by country |
| Hash-chained agent records | Tamper evidence through chained hashes | No authority: an active IETF Internet-Draft, not a standard |
The Act's logging duties attach to high-risk AI systems. Article 12 requires those systems to technically allow the automatic recording of events over their lifetime, and Article 26 puts log retention and worker-information duties on the deployers who use them. A coding agent on a developer's laptop is usually not a high-risk system in its own right, so applying these articles to it is a reasonable interpretation, borrowed as good practice, not stated law.
The line can move. Annex III lists employment uses, including AI systems used to monitor and evaluate the performance and behaviour of workers. If you start using agent decision records to judge individual employees, that use deserves its own legal review, because it sits much closer to Annex III territory than security logging does. That is an interpretation; take it to counsel.
Timing matters for planning. The Act's transparency duties under Article 50 have applied since 2 August 2026, and the obligations for the high-risk systems listed in Annex III are scheduled to apply from 2 December 2027. Our EU AI Act compliance guide covers risk classification, deployer duties and the full timeline in one place.
SOC 2 reports are attestations by independent CPA firms against the AICPA's Trust Services Criteria. The criteria don't name AI agents, but agents acting with employee credentials sit inside the logical access and monitoring expectations, and a Type II period means you need records across the whole window, not a snapshot. Expect sampling of inventory completeness, block and escalation records, policy change approvals, and access to the log store. The AICPA has published proposed 2027 updates to the SOC 2 criteria for comment and has announced an engagement that pairs a SOC 2 report with an AI agent certification, so check the final criteria before you lock this mapping.
ISO/IEC 42001 is a certifiable AI management system standard. It asks you to run AI under documented, operating controls, but it doesn't prescribe endpoint log formats, so the evidence design is yours to define and justify. NIST publishes a crosswalk between its AI Risk Management Framework and ISO/IEC 42001 if you need to align the two. Our ISO/IEC 42001 explainer covers what the standard is, who it applies to, and how it relates to other AI frameworks.
Once the records exist, an AI compliance platform can map them to controls across frameworks and collect them continuously instead of in a scramble before each audit.
Every record that names an employee is personal data, and in most deployments the employer is the controller for it. That shapes the design:
The practical rule: log the agent's actions, not the employee's behaviour. If the records start serving performance management, you've changed the purpose, and the assessment has to change with it. Our AI governance guide covers the wider policy program these privacy decisions belong to, from acceptable-use rules to risk ownership.
Auditing AI agent actions on laptops comes down to tests an auditor can reproduce on sampled devices: reconcile the inventory, trigger a denied action and trace its record, delete or alter the local log, take the laptop offline, loosen a local setting, and resolve a record to a named employee. Each test either produces evidence or exposes a gap.
| Test | How to run it | Pass condition |
|---|---|---|
| 1. Inventory completeness | Pick a sample of laptops and compare on-device fingerprints with the inventory | Every agent and MCP server found is in the inventory with an owner |
| 2. Denied action | Attempt an action policy forbids, such as reading a credentials file outside the project | The action never runs, and a record with the rule identifier reaches the off-device store |
| 3. Local log tampering | Delete or edit any log kept on the laptop | The off-device copy is unchanged, and the gap or mismatch is flagged |
| 4. Offline operation | Disconnect, run allowed and denied actions, then reconnect | Policy held offline, and records arrive with unbroken sequence numbers or a flagged gap |
| 5. Local policy override | Edit a user or project settings file to loosen a rule | Managed policy still wins, and the drift is recorded or alerted |
| 6. Attribution | Pick records at random from the store | Each resolves to a named employee and a distinct agent identity |
| 7. Privacy controls | Inspect stored records and the store's access log | Content is redacted as the DPIA requires, and reads of raw records are logged |
Run the set at the start of the audit period and again before it closes. The second run is what shows the control kept operating, which is the question a Type II auditor actually asks.
AgenShield enforces your agent policy on the Mac: it allows, flags or blocks out-of-policy actions before they execute, and it writes a per-decision record naming the agent, the user, the command or path, the rule and the verdict. It covers the enforcement and evidence capture steps above; retention, legal mapping and privacy assessment remain yours to build.
Here is what AgenShield does today, stated as plainly as the rest of this guide:
rm -rf outside the project or a read of ~/.npmrc, are allowed, flagged or blocked before they run, with no gateway or proxy in the path. A blocked action fails like a normal permission error.What stays yours to build or confirm:
For AI tools in the browser, BrowserShield is in early access with design partners only and is not generally available. It blocks unapproved AI tools and sensitive pastes into AI tools, and it collects metadata rather than prompt content. The Shield endpoint and browser protection overview shows how the two fit together.
On-device enforcement is one part of the accountability layer: identity, authorization and audit for every agent, wherever it runs. Our AI agent architecture guide shows where that layer sits relative to models, tools and gateways.
Autonomous decisions on laptops are auditable when the record is written before the action, names both the agent and the employee, and leaves the device. If you want to see what that looks like on your own fleet, run AgenShield in monitor mode on a pilot group of Macs and review the decision records with your auditor before you switch on enforcement.
These answers cover the questions security, compliance and internal-audit teams ask most often when AI agents start making autonomous decisions on employee laptops: what to record, which frameworks apply, how employee privacy limits logging, and what happens when a device goes offline. Each answer stands on its own; the sections above carry the detail.
Each record should name the agent and its session, the accountable employee as a directory identity, the device, the action attempted, the verdict, the rule and policy version that produced it, the outcome, and timing with a per-device sequence number. Add a signature so the store can detect altered records, and redact content your privacy assessment rules out.
The SOC 2 criteria don't address AI agents specifically, so coverage is a reasonable interpretation rather than a stated rule. Agents acting with employee credentials fall under the logical access and monitoring expectations in the Trust Services Criteria. Type II reports test operation over a period, so auditors typically sample inventory completeness, block records and policy change history.
Often, yes. GDPR Article 35 requires a data protection impact assessment where processing is likely to result in a high risk, and systematic monitoring of employees is a common trigger. Agent records name the employee and can reveal how they work, so plan on a DPIA in the EU and UK and record your reasoning.
Log commands and file paths when your policy decisions depend on them, but redact or hash anything likely to hold personal or secret data, and gate raw access. Prompts are rarely needed for audit. Claude Code, for example, leaves prompt and tool-detail content out of its telemetry unless it is explicitly enabled, which is a sensible default.
In several EU countries, national law gives works councils a say over technical systems that can monitor employees, and agent decision records can qualify. Rules vary by country, so involve the works council and employment counsel before rollout. For high-risk AI systems, the EU AI Act separately requires informing workers' representatives before workplace use.
A sound design keeps enforcing policy offline, buffers records on the device, and uploads them on reconnect with per-device sequence numbers so gaps are visible. Record both device time and receipt time to catch clock drift. Test it: disconnect a sample laptop, run allowed and denied actions, reconnect, and confirm every record arrives.
Maintain auditability and compliance for AI autonomous decisions by keeping three things true over time: every agent is inventoried, every action passes a policy check that leaves a signed record naming agent, employee, rule and verdict, and those records live off the device. Then retest the controls each audit period, because configuration drift is a common failure.
No. Endpoint detection and response tools record processes, files and network connections, which helps discovery and investigations. They typically don't record which agent acted for which employee, which policy applied, or whether an action was allowed, blocked or escalated. Use EDR as a corroborating source and inventory signal, not as the decision record auditors test.
No single rule covers every agent. Deployers of high-risk AI systems under the EU AI Act must keep logs for at least six months unless other law says otherwise. For other agents, set retention to cover your audit period and legal duties, then delete, because GDPR's storage limitation principle applies to records that name employees.
Keep reading
ISO/IEC 42001 is the certifiable standard for an AI management system. What clauses 4-10 and the 38 Annex A controls require, and how certification works.
Written by
Agen.co
What is an AI audit? How companies audit AI models, agent actions, decisions and data sources, the audit trail behind them, and how to get audit-ready.