Ory Powers The New Agent Security Lifecycle

Today, Ory officially launched exciting new “Build + Deploy” capabilities related to Ory Agent Security. Basically, this allows our customers to automatically infuse agentic security at scale consistently across a vast array of SDKs and APIs. To get more of the specifics, I invite you to visit our product page, go deeper with a more comprehensive blog, or watch a demo.

The net-net: Ory just took another important step in making the use of AI agents safe at scale.

But how?

Ory believes that agent security is a lifecycle that consists of four important stages -

Observe → Enforce → Build → Deploy

It is represented as a continuous lifecycle where a company can jump in at any stage and continuously improve as they move their way through all:

With the release of Build+Deploy - additional capabilities complementing the previously released Observe and Enforce modules - Ory now officially offers powerful solutions across the entire lifecycle. The complete set of components are commercially available today as a unified agent security control plane: Ory Agent Security.

Let’s dig into the individual stages to better understand why each is individually important and collectively necessary -

Observe

Turn on the lights

The new agentic action frontier demands visibility. Not an inventory spreadsheet describing which agents someone believes are running. Actual observed agent behavior.

• Which agents exist?
• Who initiated them?
• What sub-agents are they creating?
• What tools are they invoking?
• Which commands are being attempted?
• Which systems are being reached?
• Which human authority is being inherited?
• Where are credentials being shared?
• Which actions would violate a policy if that policy were turned on tomorrow?

Security teams should be able to answer those questions without disrupting the agent. And that matters greatly because you cannot intelligently govern a system you cannot see. Observation transforms agent security from conjecture into evidence.

Additionally, it creates something CISOs desperately need right now: the ability to assess agentic risk without first betting production availability on assumptions or an untested policy framework.

You need to be able to “turn on the lights”. Watch. Learn. And THEN decide what rules to put around real behaviors.

Note: The temptation for security teams is often to immediately start blocking. Everything. And that would be understandable albeit reflexive - and most likely the wrong move.

Everyone learned that lesson repeatedly before. When intrusion-prevention systems emerged, organizations realized that operating them in monitoring mode before moving into more blocking was the most prudent course of action. The same happened with web application firewalls. You first learned what normal traffic actually looked like. Then you tuned the policies and enforced them.

Agents require the same discipline, only faster. Not wholesale blocking.

Agents’ behavior is more dynamic and their pathways are less predictable. Documentation rarely reflects everything they actually do. And a policy written from an architecture diagram may bear little resemblance to the activities actually taking place inside the runtime.

The responsible approach is not Block Everything. Nor is it Trust Everything.

Instead, the new lifecycle of agent security espouses Observing and then determining what to enforce - and why - based on actual observations. Ory’s new capabilities, as they apply to the Observe layer, more easily enable you to “turn the lights on” at scale and see agent behavior across your organization automatically. And that’s a vital step forward.

Enforce

Put deterministic control around probabilistic systems

Once normal behavior is understood, enforcement can progressively begin.

Prioritize highest-risk areas and tools first:

• Destructive commands
• Sensitive repositories
• Production databases
• Privileged APIs
• Data exfiltration paths
• Actions that require explicit delegation or elevated authority.

Ensure enforcement before the action executes.

AI models may be probabilistic. Security enforcement cannot afford to be.

When the policy says an agent cannot delete a production database, modify a protected branch, access a customer record or execute a privileged command, that cannot merely be advice in a system prompt. It must become a deterministic control.

This is the vital architectural shift from guardrails around the model to controls around the action. And that’s exactly the differentiation Ory Agent Security provides.

Build

Make security part of the agent, not an attachment to it

This is the stage that changes agent security from reactive control into durable architecture. Think of it as Identity as infrastructure.

Once organizations understand actual behavior and know which actions need deterministic policy, those lessons should flow directly into how the next generation of agents is built. Identity can no longer just be bolted on - in this case after the agent is complete.

Authorization should not be added when the security review begins. Policy should not live in a separate document waiting for someone to translate it into engineering reality. “Defense in depth” demands protections at the network, endpoint, and silicon layers to protect how agents communicate, where they execute, and the underlying compute infrastructure. But the most crucial layer is at the identity layer to control what agents are authorized to do. The agent must be built from the beginning with explicit identity, permissions, delegation rules, and action-level controls. That is what "secure from the start" means in an increasing agentic world.

Observation tells us what agents actually do.

Enforcement tells us what they are allowed to do.

Build turns those lessons into applied architecture.

Developers can then create agents that are powerful by design without having to choose between unrestricted capability and brittle lockdown. The objective is not to limit what builders can create. It is to give them a safer foundation from which to create more.

Deploy

Give agents room to scale. Safely.

Once organizations can observe agent behavior, enforce policy at the point of action, and build those controls directly into new agentic systems through technology-agnostic APIs and SDKs, they have the foundation to deploy agents with confidence. What might otherwise be a leap of faith or a "Wild West" endeavor becomes a governed expansion of capability and velocity.

And scale changes everything. A single agent operating within a controlled environment presents one level of risk. Hundreds or thousands of agents (and exponentially more sub-agents), acting autonomously across applications, data sources, business processes, and organizational boundaries, introduce an entirely different level of complexity. Security cannot depend on manually configuring permissions, monitoring individual agents, or trusting that every development team will implement safeguards consistently.

Deployment must make security repeatable. Identity, delegated authority, and policy enforcement need to follow agents wherever they operate, regardless of the frameworks, models, or infrastructure supporting them. Controls must remain consistent even as agents multiply, collaborate, invoke new tools, and take on more consequential responsibilities.

That is the promise of secure deployment: organizations can accelerate innovation without allowing risk to accelerate alongside it. Security becomes an embedded, scalable capability rather than a bottleneck that must be revisited with every new agent, application, or use case.

With proper “Deploy” capabilities in place, agents can be given broader access. More consequential workflows can move into production. More teams can adopt them. Greater autonomy becomes possible because the organization knows where the boundaries are and knows those boundaries are being automatically applied.

For organizations already running agents in production, “Deploy” may mean expand: give agents more responsibility because you now have evidence, accountability and control. For new use cases, it means graduating from experimentation into production under known policy.

Deploy helps Security progress from being the department that says, “Not until we understand this.” It becomes the capability that allows the organization to say, “We understand it, we control it, we built it correctly, we trust it - and now we can scale it.” That is the ultimate objective.

Why now? What now?

This architectural decision cannot wait for the agent security market to mature over the next several years (or even quarters). Agents (and sub-agents) are already moving into development environments, enterprise workflows, and production systems. Security organizations are being asked to govern systems that are evolving faster than traditional controls were ever designed to accommodate. The control architecture and maturity needs to evolve at the same speed as the agents themselves.

Rather than solutions from the past, enterprises must now seek solutions specifically built for the Agentic Era - where Identity, authorization, and governance are inserted directly into the agent harness - the layer connecting the agent to tools, APIs, files, and systems. At the moment an action is requested, the new solution must be able to help the system evaluate the agent, the delegated human identity, the requested tool, its parameters, and applicable policy before allowing execution.

Simply blocking is not the answer. And neither are the two other extremes:

1. Trusting agents blindly.
2. Becoming so afraid of their risk that the organization cannot use them.

But a third path provides a better lifecycle model and the best way forward:

• See what agents are doing.
• Control what they are allowed to do.
• Build those controls into what comes next.
• Then give agents more freedom to work and scale.

Observe. Enforce. Build. Deploy.

It's time to solve the problem where the problem exists and do so using the right paradigm. The moment does not need another wall around the software. It needs security from the start with control from the moment software is built to the moment an agent decides to act. Success requires an agent security lifecycle and Ory now has the full set of commercially available capabilities to take the lifecycle from theoretical desire to executional reality. possible like never before. It’s available TODAY as a single control plane you won’t outgrow.

Ready to get started with “observing at scale” using Ory? For a limited time, it’s simple and free. Go here to “turn the lights on” and actually see what your agents are doing. And then move forward to establishing guardrails and enforcing with confidence as you keep agents under control. I sincerely hope that you will give us the chance to show you exactly what the intersection of security and identity for the Agentic Era looks like.