An engineer asks an AI agent to investigate a failed deployment. The agent examines logs, identifies a likely cause, and prepares a patch. By the time the engineer returns, much of the investigation is complete.
The agent has given the engineer a welcome head start, though the diagnosis and proposed patch still need a human’s scrutiny before anything reaches production. But what if the agent, in pursuit of completing the task, deleted a database that would have been incompatible with the proposed patch? Who is responsible for that action?
As agents assume more of an integral role in the workplace, engineering and security leaders face a question of responsibility: What should remain under human control when software performs the task and a person answers for the outcome? Reviewing the finished result may be insufficient if the agent has already accessed sensitive data or changed a system.
By then, rejecting the result may do little to remedy what happened along the way. For example, in July 2025, SaaStr founder Jason Lemkin reported that a Replit coding agent deleted a live production database during an explicit code freeze. Reviewing the agent’s finished output would have come too late to prevent the deletion.
Teams therefore need a shared understanding of where the agent’s authority ends and when a person must intervene, backed by controls that enforce those boundaries.
What Precedent Did Cloud Computing Establish
Cloud computing offers a useful precedent. Its shared responsibility model assigns certain obligations to the provider and leaves others with the customer, depending on the service. Moving an application to someone else’s infrastructure still leaves the customer responsible for matters such as data access.
Teams adopting AI agents need a similarly deliberate division of duties. AI providers have responsibilities for the services they supply, while the organizations deploying agents remain responsible for decisions such as granting access to internal systems and approving production changes. Within those organizations, delegating a task to an agent still leaves people accountable for the authority they grant and the results they accept.
A shared responsibility model for humans and agents must therefore connect the tasks delegated to software with the decisions people retain. It should establish who authorizes the agent’s access and who accepts its results, giving each person the controls and evidence needed to fulfill that responsibility.
1) Give the Assignment an Owner
Consider a coding agent assigned to correct a defect. An engineer should establish the intended behavior and the evidence required to accept the change. The agent might then examine the relevant code and prepare a proposed fix, including tests. That division leaves substantive questions with the engineer:
• Do the tests examine the requirement independently, or merely confirm the agent’s interpretation?
• Does the change introduce consequences outside the original assignment?
• Who has authority to approve its release?
Review can become perfunctory when the person receiving a finished patch has neither the context nor the time to examine it properly. Assigning an owner means giving that person a defined decision and sufficient evidence to make it.
2) Make Responsibility Enforceable
Written assignments become tenuous when the agent’s access permits substantially more than the assignment requires. An instruction to stay within a test environment offers little assurance if the agent can use credentials that also reach production.
Security and platform teams should translate the agreed division of authority into access policies enforced outside the agent’s own reasoning. Application owners must identify the resources and operations an assignment requires.
Enforcing those policies requires knowing which agent is acting and, where applicable, whom it represents. Access decisions should consider both identities while preserving each in the audit record. Without that, the record may conflate a person’s direct actions with software acting under delegated authority.
Aembit supports this part of the model through verified agent identity and runtime access policies. Its blended identity approach considers the agent alongside the person it represents, allowing access decisions and audit records to retain that distinction. Security teams can also revoke an agent’s access independently when intervention is necessary.
3) Put Division of Responsibility into Practice
Regardless of the technology or vendor involved, teams need to make these responsibilities part of their everyday procedures. Start with one agent-assisted process and use the following practices to establish who makes each decision and how the agreed limits will be enforced:
- Name the person who accepts the result. Give that person explicit acceptance criteria and enough context to assess the agent’s output.
- Separate investigation from intervention. An agent may need to read production logs; changing production configuration requires separate authorization.
- Check permissions against the assignment. Verify that access controls prevent actions outside the agreed scope, including attempts to invoke restricted tools directly.
- Test how intervention works. Confirm that an authorized person can revoke the agent’s access and that records distinguish the agent’s actions from the human’s.
Shared Responsibility Requires Shared Control
When something goes wrong, the division of responsibility should be clear enough to explain how it happened. The engineer owns acceptance of the change; the people administering access own the permissions that made its execution possible. An incident review needs evidence of both, particularly where the scope a person approved differs from the access the agent actually held.
The same standard should apply before an incident. If a person is expected to answer for an agent’s actions, that person needs the authority and means to limit them. Otherwise, the organization has assigned someone the blame without giving them control.
A shared responsibility model earns its name only when the people who retain responsibility also retain the power to decide what happens next.