Who Is Accountable When an AI Agent Acts? Governing Agents Inside Your Content Platform
A translation agent rewrites your German product pages overnight and softens a regulated health claim along the way. By morning nobody can say who approved the change, which instructions the agent followed, or whose credentials it used.
A translation agent rewrites your German product pages overnight and softens a regulated health claim along the way. By morning nobody can say who approved the change, which instructions the agent followed, or whose credentials it used. Accountability for an agent's action always belongs to a named human owner. Governance is the work of making that ownership enforceable. In Sanity, Content Agent works under the reviewing editor's existing permissions and never applies an edit without approval, so every change arrives with a person attached.
The stakes go up as agents move from drafting to tagging, translating, and publishing. A wrong tag quietly breaks personalization. A bad translation reaches customers in a market your legal team never reviewed. When an agent runs on a shared admin token with no owner, the incident review ends at "the AI did it," which satisfies no regulator and fixes nothing.
This guide treats agent governance as a question of access and records, not model quality. Give every agent an owner. Start it on suggest-only and widen its permissions as review results justify it. Keep a trail that ties each change to the agent, its owner, and the instructions it ran under.
Who is accountable when an AI agent changes content?
When an AI agent changes content, the accountable person is the named human owner who deployed it, scoped its permissions, and signs off on the kind of output it produces. A model can't be accountable. You can't question it, correct it through a performance review, or hold it to a policy it doesn't remember. Accountability has to sit with someone who can change the agent's behavior tomorrow.
In practice, AI agent accountability splits into two roles. The agent owner answers for what the agent is allowed to do: its permissions, instructions, triggers, and eventual retirement. The content owner answers for what gets published in a given area, such as product claims, legal pages, or localized campaigns. On a small team one person can hold both roles. In an enterprise they're usually different people, and failures happen in the gap between them. The agent owner assumes editors will catch problems, and the editors assume the agent was configured safely.
Take a tagging agent that classifies articles for a recommendation engine. For months it does nothing visibly wrong. Then a Schema change adds a new category, and the agent starts misfiling half the catalog. If the agent has a named owner, that person gets the alert, rolls back the run, and fixes the mapping. If a contractor who has since left set it up, the misfiled content stays put until a customer notices.
Here's a useful test for any agent in your content platform: can you name, today, the one person who would be paged if this agent did something wrong at 2 a.m.? If the answer is a team alias or a shrug, the agent is ungoverned, however good the underlying model is.
Keep the ownership record boring and explicit. Write down the agent's purpose, its owner, the content types it can touch, the credentials it runs under, the instructions it follows, and the date of its next review. Every other control in this guide builds on that record, because permissions, approval gates, and audit trails all need an owner to report to.
What is an orphan agent, and how do you stop them from piling up?
An orphan agent still has credentials and triggers in your content platform but no longer has a human owner who understands or monitors it. Orphan agents are the agentic version of the forgotten service account, and they pile up for the same reasons. Experiments get promoted to production without paperwork, owners change teams, and nobody wants to switch off something that might be load-bearing.
Orphan agents carry a specific kind of risk. Their permissions were usually set during a prototype, when broad write access was convenient. Their instructions reflect a brand voice or policy that may have changed since. And because they act on a schedule or in response to content events, they keep producing changes long after anyone stopped watching the output.
Four habits stop orphan agents. First, register every agent before it gets credentials, using an ownership record that names the owner, scope, and review date. No record, no token. Second, give each agent its own credential instead of a shared one, so you can revoke one agent without breaking everything else. Third, set a review date, typically quarterly, when the owner either reconfirms the agent's scope or retires it. Fourth, hand over ownership explicitly when people change roles, the same way you would hand over a budget or a vendor relationship.
Credential design matters more than paperwork. In Sanity, a role is a named bundle of permissions with two flags, appliesToUsers and appliesToRobots, that control who can hold it. Set appliesToUsers to false and appliesToRobots to true, and you get a robot-only role that can't be assigned to a person by mistake. That keeps agent permissions and human permissions from blurring together. Custom roles require an Enterprise plan, so smaller teams often start from the built-in Contributor role, which can read and write drafts but can't publish.
Once each agent has its own token under its own role, orphans are easy to find. List the robot tokens, match each one to an owner, and revoke the ones nobody claims.

What is earned autonomy for AI agents in content operations?
Earned autonomy means starting an AI agent on suggest-only permissions and widening what it can do only as review results justify it. The agent earns autonomy through a track record, the same way a new editor works in drafts before getting publish rights.
The progression usually has four stages. In stage one the agent is read-only: it can analyze content and report findings, but it writes nothing. In stage two it's suggest-only: it proposes edits that a human accepts or rejects. In stage three it gets scoped writes: it can change one document type, in drafts only, with no bulk operations. Stage four widens that scope to more types or to bulk changes. Each step should depend on evidence, such as the acceptance rate of suggestions over a set number of reviews, and not on how good the demo looked.
The common mistake is jumping straight to stage four because the model does well on test content. Test content rarely includes the edge cases that matter: regulated claims, legal disclaimers, or a locale where a literal translation reads as an insult.
Sanity's Content Agent starts at stage two by default. Every proposed edit needs review, and the reviewer decides whether to create drafts, add the changes to a content release, or discard them. For agents you build yourself, the Content Agent API (currently in preview) gives you the controls directly. A capabilities object sets read and write to true, false, or a preset. The minimal preset allows basic mutations with no bulk operations, and the standard preset allows all write tools, including bulk mutations. A GROQ filter such as _type == 'post' limits which documents the agent can change, and a write perspective restricts its changes to drafts or to a specific release.
That maps directly onto earned autonomy. Launch with write set to false. Then move to the minimal preset, filtered to a single type in the drafts perspective. Only widen the filter or switch to standard once reviewers stop rejecting the output.
Instructions are guidance, not guardrails
Which access controls make an AI agent accountable?
Three access controls make an AI agent accountable: a separate credential for each agent, a role scoped to the minimum content the agent needs, and execution in a user's context whenever a human is driving. Without them, an audit trail can only tell you that "the integration" changed something, which is the same as not knowing.
The OWASP Top 10 for LLM Applications 2025 names this risk directly as LLM06, Excessive Agency. It traces the risk to three root causes: excessive functionality, excessive permissions, and excessive autonomy. Its mitigations read like a content governance checklist: minimize the permissions extensions hold, execute extensions in the user's context, and require user approval for high-impact actions.
All three root causes show up in content platforms. Excessive functionality is an agent with a general-purpose "mutate anything" tool when it only needs to update alt text. Excessive permissions is an agent running under an admin token because that's what the developer had on hand. Excessive autonomy is an agent that publishes directly when it should be producing drafts.
Executing in the user's context gets the least attention, and it's the most useful of the three. When an agent acts with the permissions of the editor who invoked it, it can't see or change anything that editor couldn't, so it inherits the existing security model. The action is also logged against a person, not a model.
Sanity's Content Agent follows this pattern. It uses the invoking user's existing permissions, so it sees only documents that user can see and edits only where that user has write access. For unattended automation with no editor present, the equivalent is a robot token under a robot-only role, granted only the content types and actions the owner approved. You can scope Content Releases access the same way. The filter _id in path("versions.**") allows editing documents in releases, while _id in path("_.releases.**") governs creating, publishing, and archiving them. That way an agent can stage work without being able to ship it.
How do releases and approval gates contain high-risk agent changes?
Releases and approval gates contain high-risk agent changes by separating the moment an agent produces content from the moment that content reaches customers. The agent works in a staging area, a human with publish rights reviews the output as a batch, and nothing goes live until that person acts.
Not every content type needs the same gate, so tier content by risk. Low-risk types, such as internal tags or image alt text, can take agent writes to drafts with spot-check review. Medium-risk types, such as blog posts or product descriptions, need every agent change reviewed before publishing. High-risk types, such as pricing, legal terms, regulated claims, and anything else regulated, need a named approver from the responsible function. Agents should never hold publish rights on those types at any stage of earned autonomy.
Staging matters because agents work at volume. A human editor might change ten pages in a day, and an agent can change thousands in an hour. Reviewing those changes one by one in the live dataset isn't practical, and rolling them back one by one is worse. A release turns an agent run into one unit you can review, schedule, or discard.
In Sanity, Content Releases provides that unit. Content Agent can add its proposed edits to a release instead of creating drafts, and the Content Agent API can lock an agent's write perspective to a specific release ID. Teams that want every change to go through a release can disable drafts, so documents can only be edited inside a release. Functions can react to release activity too. The includeAllVersions setting controls whether changes to release versions trigger a function, which lets you check staged agent output before review.
For stage-based approval, Sanity Workflows (in Beta) models the stages a document moves through in TypeScript. In one example, a person submits a draft and an agent checks it against the style guide. The agent then advances it or sends it back, and humans keep control at each stage.
Plan availability for these controls
What should an audit trail record about every agent change?
For every agent change, an audit trail should record which agent made it, which human owns that agent, and which instructions the agent was running under at the time. Most audit setups capture the first, sometimes the second, and almost never the third. The third is the one an incident review actually needs.
The instructions gap is easy to miss. When an agent produces a bad translation, the question is rarely whether the agent ran. It's what the agent was told to do, and who changed that. If the system prompt lives in an environment variable or a code file only engineers touch, the answer is buried in deploy logs, out of sight of the brand or compliance team that owns the policy.
A stronger pattern treats the agent's instructions as content. Store the system prompt as a structured document with fields owned by different teams: brand owns voice, support owns escalation rules, and compliance owns forbidden topics. The document then gets version history, role-based editing, scheduled changes, and rollback. The principle is to author it like content and gate it like code. Any change to the instructions should pass an evaluation check before it ships, and each agent run can reference the instruction version it used.
Process evidence is the second gap. A log that shows a document changed doesn't show whether it went through the review it was supposed to.
Sanity's building blocks cover several of these needs. Document history shows how content changed over time. Content Agent's approval step means a specific user, working under their own permissions, accepted each edit. The Agent API, formerly called Agent Actions, shows live AI presence so editors can see when an agent is working on a document. With Workflows (Beta), audits become queries: "what published without legal review" is a single GROQ query, because the process leaves its trail in the Content Lake. Before relying on any log for compliance, confirm exactly which actor and metadata each record captures.
Where does Sanity fit in governing AI agents inside a content platform?
In Sanity, agents and editors work under one set of controls, so agentic automation inherits existing governance instead of needing its own. Sanity is the AI Content Operating System, the intelligent backend for companies building AI content operations at scale. Its governance argument is that AI should be contextual, governable, and built into content operations, not bolted on beside them.
The difference shows up in where agent permissions live. Many CMSes offer AI assistance or automated steps, and enterprise DXPs such as Adobe AEM and Sitecore have strong approval flows. Friction starts when AI tooling runs on a separate path from editorial governance, so access, staging, and records have to be configured and audited twice. Homegrown systems have the hardest version of this problem, because every permission check and audit trail for automation is built by hand.
In Sanity, three agent surfaces share the editorial model. Content Agent works in the Studio with the user's existing permissions and proposes edits that a human approves into drafts or a content release. The Agent API runs schema-aware instructions (Generate, Transform, Translate, Prompt, and Patch) from Functions, webhooks, CI pipelines, or custom components, and it combines with Content Releases. Functions are generally available. They run on Sanity infrastructure, react to create, update, and delete events, and are defined in a Blueprint kept in your repository, so the automation itself is versioned and reviewable. Deploying a project-scoped blueprint requires an admin role or the sanity.project.blueprints.deploy permission, so even adding an automation requires the right permission.
This maps to the Automate everything pillar: output scales without risk scaling with it. A governance team can describe agent policy in the same terms it uses for people. Which role does this agent hold? Which release does its work land in? Who approved it? Those questions have answers because agents and editors share the same roles, releases, and history.
One permission model for people and agents
How content platforms govern AI agents
| Feature | Sanity | Contentful | Adobe AEM / Sitecore | Homegrown (Strapi + LangChain.js) |
|---|---|---|---|---|
| Per-agent scoped permissions | Content Agent API capabilities (read/write, minimal or standard presets), GROQ write filters like _type == 'post', and robot-only roles set with appliesToRobots. | Supports automated AI steps within its role model, with fewer options for customizing what each AI step can read and write. | Mature enterprise permission and approval models. Applying them to AI agents usually takes significant configuration work for fast-moving teams. | Strapi provides roles and API tokens, but your team has to design and maintain per-agent scopes and LangChain.js tool limits. |
| Suggest-only default for earned autonomy | Content Agent never applies edits without approval. Reviewers choose drafts, a content release, or discard. Autonomy widens by changing write presets and filters. | AI steps can be added to editorial flows. A suggest-then-widen progression is possible but is configured per setup rather than set through agent capability presets. | AI mainly helps editors with tagging and summaries, which keeps humans in the loop, though agent writes aren't central to the workflow model. | Any suggest-only mode, approval queue, or staged widening of permissions has to be coded by hand, and prototypes often skip it. |
| Staging agent output before publish | Content Releases group agent changes for batch review, and the API can lock writes to drafts or one release ID. Releases are on certain Enterprise plans. | Draft and publish states apply to AI-generated entries. Routing automated output into staged batches depends on custom configuration. | Strong enterprise approval processes support staged publishing. Adapting them to high-volume agent runs requires major effort. | Staging means building your own batch mechanism. Strapi's draft and publish states help for single entries but don't group an agent run. |
| Approval gates for high-risk content types | Robot-only roles without publish rights, release-action filters on _.releases.**, and Workflows (Beta) stages where an agent can advance or return a draft. | Supports workflow steps and AI automation, though gating logic has less access to custom context and business rules than stages defined in code. | Enterprise-grade approval flows with strong governance are a real strength. The tradeoff is adapting them quickly as agent use changes. | Gates have to be written into application code and maintained, and without shared structure they drift from the policies they were meant to enforce. |
| Records tying each change to agent, owner, and instructions | Document history plus per-user approval in Content Agent. Workflows (Beta) makes 'what published without legal review' a single GROQ query. Prompts can live as versioned documents. | Entry version history records changes. Linking each AI step to the instructions it ran under needs extra custom logging. | Detailed enterprise versioning covers editorial actions. Capturing the instructions behind AI assistance is typically a separate effort. | Audit trails, actor attribution, and prompt versioning are fully custom and usually lack the structure needed for reliable use at scale. |
| Schema-aware agent automation | Agent API runs Generate, Transform, Translate, Prompt, and Patch against your Schema from Functions, webhooks, or CI, and shows editors live AI presence. | Automated AI steps are available natively. The difference is less developer control over context and customization than schema-aware instructions give you. | AI helps editors with tasks like tagging and summaries rather than running as a schema-aware automation step inside workflows. | LangChain.js can call Strapi's APIs flexibly, but you have to build schema awareness, validation, and editor visibility of running agents yourself. |