AI Agent Security Requires Action-Level Controls Across the Full Lifecycle

AI agents expose a gap in enterprise security: valid credentials can authorize an operation that the person behind them never meant to delegate. The agent may interpret a broad objective, choose a tool, and take a consequential step on its own. Governing access to a system therefore doesn’t necessarily govern what an agent will do once inside it.
That changes where security decisions need to happen. Teams need to know which agent is acting, whose authority it carries, what operation it is requesting, and whether policy permits that operation on the target resource. My read is that this calls for security controls woven through the agent’s lifecycle, with authorization checked close to execution.
Credentials tell only part of the story
Traditional identity controls answer important questions: who is requesting access, whether that identity is valid, and which systems it may reach. Agents complicate the picture because they can interpret objectives, choose among tools, sequence operations, and spawn sub-agents. They may do all of this using permissions inherited from a human or service account.
A developer’s credentials might be legitimate, and the traffic might pass network checks, while an agent attempts to delete a production database. An identity provider can validate the developer. Runtime controls can recognize an approved process. Neither result establishes that the agent should be allowed to perform this particular operation.
The distinction is between access to a system and authority to take a specific action within it. That calls for authorization at the point of action, using the agent’s identity, delegated authority, requested operation, target, and applicable policy. A trusted enforcement point should evaluate those details before the operation runs.
The agent harness, which connects a model to tools, APIs, files, and other systems, is one place to make that check. Harness controls work alongside checks in tool services and resource APIs. The broader security stack still matters: network, endpoint, runtime, infrastructure, hardware, and model protections each address different parts of the problem.
Here’s the thing: a prompt telling a model to behave safely is not an authorization boundary. A model can pursue an objective through different tools or paths across separate executions. Security policy needs to be enforced consistently even as those paths change.
Four connected disciplines
A practical program can be organized around four disciplines: observe, enforce, build, and deploy. They inform one another continuously rather than acting as a fixed sequence of approval gates.

An organization with agents already in production may start by examining their activity. A team building a new agent can incorporate identity and authorization from the outset. As deployments grow, fresh production evidence can reveal missing controls or policies that need revision. Each entry point contributes to the same operating cycle.
Observe what runs, not just what’s configured
An inventory can show which agents exist, but it can’t establish what they actually do. Security teams need execution evidence: the tools and APIs invoked, commands issued, systems and sensitive resources accessed, and credentials or delegated permissions used. They also need to see whether an agent creates sub-agents, what authority those agents receive, and which attempted actions would conflict with a proposed policy.
Configuration files and architecture diagrams offer context, but they don’t capture every path an agent takes at runtime. Agent observability needs to connect activity with identity, delegation, and authorization context. Conventional logs and application monitoring may not provide that complete view on their own.
There’s a practical reason to observe before enforcing aggressively. Organizations adopting intrusion prevention systems and web application firewalls learned that blocking rules can interrupt legitimate work when teams haven’t established normal behavior. Monitoring first lets them assess how policies would affect production before turning those rules into automatic denials. Agents make this discipline more relevant because their behavior can vary as they pursue an objective.
For a company already running agents, the first useful move may be to find out what activity is taking place. A list of deployed agents is a starting point; visibility into their actions is what lets a team govern them intelligently.
Enforce boundaries for each operation
Once teams can see agent behavior, they can define which operations are allowed, restricted, or prohibited. A coding agent might be permitted to read a repository, require human approval before changing a protected branch, and be denied permission to delete the repository. The agent’s identity and environment may stay constant while the required policy decision changes with the operation and target.
A useful authorization request can identify the acting agent, the person or service that delegated authority, the requested action, and the resource. For example, a coding agent acting under a developer’s delegated authority could request deletion of a production source repository. Policy can then deny that operation before it executes.
High-risk actions may need a denial or explicit human approval; lower-risk actions may proceed automatically. The aim is to make the agent’s authority clear and enforceable while leaving room for permitted work. That decision belongs at a trusted control point, rather than relying on the model to select the safest option every time.
Coverage matters. A check in the harness protects requests that pass through the harness, but agents may have other routes to a tool or resource. Independent authorization at APIs, tool servers, and underlying resources adds protection if an agent takes an alternate path.
Build identity and policy into agent applications
Teams use different models, frameworks, tool protocols, and execution environments. If each team must design identity propagation, delegated permissions, authorization, and audit records from scratch, controls will vary and become harder to maintain. Shared SDKs, APIs, and authorization services can make those capabilities available as common infrastructure.
An agent should have an identifiable execution context, and its authority should be explicitly delegated and limited. Sensitive tool calls should receive authorization checks, while consequential actions and decisions should leave an audit trail. Security architecture also needs to preserve those limits when an agent invokes tools under service identities or creates sub-agents.
Consider an employee asking an assistant to reconcile invoices. The employee might be allowed to review invoices, approve payments, and update vendor records, while the assigned task requires only invoice retrieval and reconciliation. Giving the agent every permission available to the employee would exceed what the task calls for. Delegating only the necessary authority makes the boundary explicit.
Reusable controls also make it easier to adopt a new model or framework without recreating the authorization design. Developers can work with security capabilities as part of the application architecture, while security teams maintain shared expectations across implementations.
Deploy controls at the pace of agent activity
Operating many agents across departments, applications, and cloud environments adds a scale problem. Manual permission reviews and team-by-team implementation become difficult to sustain as agents invoke more tools, work across authorization domains, and coordinate with other agents.
Deployment architecture needs to carry identity, delegated authority, policy, and audit requirements across supported environments. Framework-independent interfaces and centrally managed policy can help maintain consistent controls as teams adopt different tools. The model or framework shouldn’t determine whether an agent receives security checks.
Agent scale also involves the number of decisions and operations in play. More agents can mean more tool calls, more independent actions, and additional agents created along the way. Security controls must make authorization decisions automatically and consistently as that activity grows.
Production then supplies new evidence. Teams can spot unexpected workflows, dependencies, and gaps in authorization, and use what they learn to refine policies and inform the next round of agent development. Deployment feeds observation; observation shapes enforcement and design. The cycle keeps running as models, tools, and workflows change.
Security as infrastructure for autonomy
Least privilege, zero trust, separation of duties, identity federation, and defense in depth remain useful principles. The change is how closely controls need to follow an agent’s actions and how consistently teams need to apply them throughout development and production.
Three operational shifts follow. Visibility needs to reflect actual behavior, not configuration alone. Authorization needs to evaluate each operation in the context of identity and delegation. And the capabilities that support both need to be reusable, so they travel with agents from development into production and back into ongoing improvement.
Organizations can respond by granting agents broad access and trusting credentials and instructions, or by restricting them so tightly that useful work becomes difficult. Neither approach provides a durable basis for autonomy. The more workable path is to establish what agents do, enforce clear boundaries around what they may do, and build those controls into the systems that run them.
Success depends on enabling valuable actions with confidence, while making consequential operations accountable and bounded. For technology leaders, the practical takeaway is to treat agent security as a continuing operating capability: instrument execution, authorize actions at trusted points, and let production evidence improve the controls.
The post AI agent security is a lifecycle — not a gatekeeper appeared first on The New Stack.