By Kareena Bavisi, Chief of Staff to CEO at EC-Council

I set out to understand why companies still don’t think they’re adequately covered. What I found looks like a pattern the insurance industry has lived through once already: multi-factor authentication went from a nice-to-have to a near-universal underwriting expectation in a matter of years, and insurers that got burned by its absence started pricing around it, denying claims over it, walking away from risks that didn’t have it. AI governance is tracing the same path, earlier, but faster. It isn’t a formal requirement anywhere in the cyber insurance market yet. But the data in this piece says it’s headed there, and the companies that treat it as optional for too long are going to find that out the same way the MFA holdouts did.

Here’s a number that should worry any CISO building an AI governance program right now: 74% of professionals who evaluate, deploy, secure, or govern AI at their organizations believe they could pass an AI compliance audit today. Only 27% describe their governance program as fully mature. That’s according to Schellman’s State of AI Governance Report 2026, a survey of 525 U.S.-based practitioners, and it’s close to an exact echo of a number I’d already been sitting with: in Munich Re’s 2026 Global Cyber Risk and Insurance Survey, 89% of C-level respondents say they don’t consider their company adequately protected against cyberattacks, up from 81% in 2021, 83% in 2022, and 87% in 2024. Two different surveys, two different questions, the same shape: confidence and reality keep drifting apart, and whatever’s being done about it isn’t closing the gap.

Bob Parisi, Head of Cyber Solutions for North America at Munich Re, has spent nearly three decades underwriting cyber risk. I asked him why. His answer wasn’t about a missing product. It was about two groups of people who don’t speak the same language.

A literacy problem, not a product problem

“Dealing with financial risk transfer is not something a CISO deals with every day,” he told me. The reverse is just as true: underwriters are pricing a technical risk they don’t observe directly, working from what a company represents about itself once a year, usually through a broker-scheduled call. “ We typically engage with them once a year when they fill out the application,” he said. Where that changes, he told me, is in companies where the CISO, CFO, and chief privacy officer are already talking to each other internally, those are the ones that end up buying coverage closer to their real exposure.

His own company’s data backs that up. Asked what’s holding back better cyber defense, Munich Re’s survey found the top two answers were both about people, not tools: “low security awareness among employees” (40%) and a lack of skilled personnel (31%), both ahead of budget. The disconnect Parisi described anecdotally is the top-ranked problem in his own company’s data.

That disconnect is what got me thinking about how to close it, and it’s why companies like the Cyber Insurance Academy exist. The talent gap behind it is well documented: insurers report more than 400,000 open positions across lines of coverage, cyber underwriting pay runs well above a typical broker’s, and the shortage persists anyway, because, as Gallagher’s Joey Sylvester has put it, “there are a very limited number of individuals specializing in this class of business” who can keep up with both the insurance market and the cybersecurity industry at once. That’s the same disconnect Munich Re’s own survey flagged as the top two defense challenges: low security awareness and a shortage of skilled people, not budget. Closing it takes skilled people who’ve actually sat through the training, courses like the CCIS, built to give security and insurance professionals enough of each other’s language that the once-a-year application conversation reflects real exposure, instead of two sides talking past each other.

What MFA can tell us about where AI governance is headed

This is where I think the Schellman number matters more than it looks on its own. AI governance right now sits roughly where multi-factor authentication sat two or three years ago, something insurers were starting to care about, but not yet something they’d decline a policy over. That’s changed fast. Brokers who place cyber coverage say MFA has gone from a minor underwriting factor to close to a hard requirement in the span of about two years. Insurers that once quoted risks without MFA, sometimes with a small premium loading, have largely stopped offering that option. Integrity’s Colin Fox says only a handful of insurers will still write a policy without it, describing it as “quite a rarity these days” in comments to Insurance Business UK.

AI, in Parisi’s words, is “first and foremost” in what Munich Re is watching right now. “It takes up a lot of the oxygen in the room in any discussion around cyber risk,” he told me. That’s not a formal policy change, but pricing is where MFA’s history is instructive. The pattern with MFA wasn’t that insurers added a new exclusion, it was that a control quietly moved from a nice-to-have to a baseline expectation, and companies that couldn’t demonstrate it found their options narrowing. Endpoint detection and response looks to be following the same track; brokers describe it as already close to mandatory for companies seeking higher coverage limits.

AI governance looks like it’s on the same curve, just earlier. 71% of C-level respondents in Munich Re’s survey now call AI significantly relevant to their business, up from 62% two years ago, overtaking cloud computing as the most-flagged technology. That’s the kind of inflection point MFA passed through before it hardened into a requirement.

What underwriters are actually scoring

No single AI tool moves the needle on its own. Deploying a specific product doesn’t earn a company a flat discount on premium. What underwriters are actually pricing, Parisi explained, is maturity, whether a company can show it’s using AI deliberately rather than just enthusiastically, and he pointed to three signals in particular.

• Overexuberance. A security team that has rushed to deploy AI everywhere without building the process to manage it first.
• Denial. A company that insists it isn’t using AI at all. Parisi’s read is that it’s there whether leadership acknowledges it or not.
• Disciplined adoption. A company that treats AI as genuinely new, testing it deliberately and rolling it into production only once it’s confident the rollout strengthens the organization rather than exposing it.

“Knowledge is power,” he told me. “Anything that helps a company better understand its risk, and articulate how it’s managing and mitigating that risk, will be viewed very positively by our underwriters.” That kind of structured, documented governance work, something a company can actually point to, is exactly what reads as a green flag to him. AI governance, in particular, is shaping up as its own discipline, distinct from general security literacy, and the organizations building that competency deliberately, rather than picking it up as they go, are the ones standing out.

That same logic, structured proof of risk maturity that underwriters can actually price, is my own case for why EC-Council’s CRAGE certification and its underlying Adopt, Defend and Govern (ADG) framework exist. ADG, developed with input from 23 advisory members across the industry, and CRAGE under it train practitioners to produce exactly the kind of documented risk articulation that reads as a green flag to an underwriter, translating AI governance maturity into terms a cyber insurer can price.

Schellman’s own numbers back this up from a different angle: companies with mature AI governance programs have AI agents running in production at more than three times the rate of companies with developing programs, 78% versus 22%. The gap isn’t just about compliance paperwork. Mature governance correlates with companies that are actually further along in deploying the technology with confidence.

The bottom line

Parisi’s advice from the underwriting side was simple: stop treating the insurer conversation as a compliance form, and start treating it like a board conversation. “Think of the cyber insurers as if you were talking to your board of directors, because that’s really the perspective we’re looking at this from,” he told me. “We don’t want to know which edition of the software you’re using. We want to know you have the right processes and protocols for making sure that software is updated and deployed, and an understanding of what the potential financial loss is if it goes wrong.”

Put the two patterns side by side, and AI governance is not going to stay optional. MFA went from a footnote to a wall in about two years once insurers decided it was a real predictor of loss, and the Schellman numbers suggest the market is already sorting companies into those who can prove maturity and those who can’t. The 89% of executives who don’t feel protected today have a narrowing window to close that gap before it closes on them, and closing it looks a lot like what this piece has been circling the whole way through: literacy on one side of the table, documented maturity on the other.

Kareena Bavisi, Chief of Staff | EC-Council

Kareena Bavisi is a contributor to CISO MAG covering cybersecurity and AI, writing on how emerging technology is reshaping risk, governance, and the way enterprises defend themselves. Her work draws on conversations with security leaders, insurers, and technologists across the industry to surface the trends shaping the field. She is also Chief of Staff to the CEO and Founder at EC-Council, a global leader in cybersecurity certification and education.

The post Why AI Governance Is Becoming Cyber Insurance’s Next MFA appeared first on CISO MAG | Cyber Security Magazine.

By Jay Bavisi, Founder & Group President, EC-Council

Nuclear treaties stopped bombs. They don’t stop a file you can email.

That’s the problem with reaching for the Nuclear Non-proliferation Treaty every time someone brings up AI risk, and last week gave everyone a reason to reach for it.

Dario Amodei published an essay arguing that the industry needs to pace itself because alignment work can’t keep up with how quickly capability is advancing now that models are helping build the next generation of models. Sam Altman agreed within hours. Elon Musk agreed in three words. Demis Hassabis agreed too and tied it back to a standards proposal DeepMind floated in July. Three men who spend most of the year competing for the same customers found, for one weekend, something to agree on.

The market didn’t wait for the philosophy to settle. By Monday, cybersecurity names including CrowdStrike, Palo Alto, Okta, Zscaler, and SentinelOne were up double digits. Semiconductor and infrastructure names sold off. Read that as the market’s actual translation of the essay: agents that can act on their own are a threat, and threats get budget. That reaction told you more about where this is headed than the essay did.

President Trump answered the next morning. The United States is leading China in AI, he said, and closed with a line that’s going to outlive most of the commentary around it: whoever wins AI wins. China’s Foreign Ministry answered within the same news cycle, calling the whole slowdown conversation fearmongering. Two governments, the only two whose cooperation a real treaty would need, both declined the premise within three days.

I’ve spent two decades building certification and training programs for the cybersecurity industry, and I’ve watched more than one generation of “we need a global framework for this” conversations play out. They rarely arrive in time to matter. So before anyone spends another year drafting a treaty that depends on Washington and Beijing agreeing to slow down together, it’s worth being honest about why the model doesn’t fit.

The NPT works, to the extent that it works, because it governs a physical thing. Uranium has to be enriched through a small number of known industrial processes, and once it is, it can be weighed, sealed, and tracked. Inspectors can put a camera on a centrifuge hall. Nobody’s smuggling a nuclear core through customs undetected.

AI doesn’t have that constraint. Once a model finishes training, what you’re actually trying to govern, its weights, is a file. It moves at the speed of a network connection. It can be copied to a laptop and walked across a border in someone’s bag. That isn’t hypothetical. It’s close to what Anthropic’s own threat reporting describes happening today. There’s no equivalent of a Significant Quantity for a neural network. No inspector can walk into a data center and certify that a company hasn’t quietly fine tuned an unmonitored version of its flagship model on a cluster the treaty never knew existed.

Even judged solely on its own terms, the NPT never reached full compliance. Four nuclear armed states sit outside it. If the best verification regime in history, pointed at the easiest possible target, still has holdouts, a treaty aimed at software is not something I’d bet a security program on.

So set the treaty down. Look at where the risk is actually piling up, because it isn’t sitting in a policy draft somewhere in Geneva. It’s sitting in poured concrete.

Global data center spending is on track to clear a trillion dollars this year, making this the largest infrastructure buildout in corporate history, and it isn’t pausing for anyone’s governance conversation. Microsoft, Amazon, and Google are signing nuclear power contracts spanning multiple decades just to keep the buildout fed. Every one of those facilities will eventually run agentic systems with real authority inside finance, healthcare, logistics, and government.

That’s the proliferation problem that actually matters. It is not weapons grade material crossing a border. It is compute, capital, and decision making authority scaling faster than most organizations’ ability to watch what they’ve built.

I’ve sat in enough boardrooms this year to put a name on the pattern: shoot first, ask questions later. A division stands up an agent to handle claims, customer support, or code review, and the governance conversation happens after the incident report, not before the rollout. IBM’s most recent Cost of a Data Breach Report puts a real number on this. Unsanctioned AI use, often called shadow AI, adds roughly $670,000 to the average cost of a breach and shows up in about one in five breaches studied. Netskope’s own 2026 data finds that a large share of enterprise generative AI traffic still runs through personal, unmanaged accounts, bypassing every control a security team thinks it has in place.

Companies are adopting this technology at press release speed and governing it at compliance calendar speed, and the gap between those two speeds is where the losses live.

A tool is not a control. I’d put that on a slide in front of any board that thinks buying an AI platform closed this risk out. It’s the 2026 version of buying a firewall in 1999 and calling the network secure. The firewall did something. It didn’t do the thing you needed.

Three words have started organizing how I think about the sequence a responsible rollout actually follows: Adopt. Defend. Govern.

Adopt, because sitting the technology out isn’t caution. It’s a slower way to lose ground. Defend, because the moment it’s live, you’re running a system capable of independent action inside your most sensitive environments, and it earns the same seriousness you’d give any system that touches money or patient data. Govern, because defense without governance is a fire extinguisher nobody’s assigned to check.

Say those three words enough times in a planning meeting, and they start reordering the meeting itself. Adoption comes first, but never by itself.

Underneath that sequence is a harder shift than most executives have made yet: moving from certifying a system once to governing it continuously. Traditional compliance assumes deterministic software. You test it, confirm that it behaves the same way every time, certify it, and revisit it next year. Agentic systems break that assumption at the root.

Run the same agent against the same task twice, and you can get two different sequences of action because the behavior is nondeterministic by design. A certificate from launch day tells you almost nothing about what that system does 200 days later, after it’s been fine tuned, wired into new tools, or handed a task nobody scoped for it up front.

That’s what people mean when they talk about a harness and context, and it’s worth saying plainly instead of leaving it as jargon. A harness is the boundary an agent operates inside. It defines what data the agent can touch, what it can do without a human, and where an action has to stop and wait for sign off before something irreversible happens.

Context is the evidence sitting underneath every one of those actions. It captures not just what the agent did, but why it was allowed to do it, under whose authority, and against which control. Put the two together, and you get something neither a treaty nor a one time audit can give you: a system that’s still governable while it’s running, not just at the moment somebody signed off on it.

None of this works without people who know how to run it, and this is where most enterprises are underinvesting relative to what they’re spending on the technology itself. I’d point to three groups.

Security teams need offensive AI ability as a baseline skill, not a specialty. For 20 years, training taught the profession to find the vulnerability, patch the system, and watch the logs while defending a target that behaved predictably. That skill isn’t going away, but it stops being sufficient once the thing you’re defending, and increasingly the thing attacking you, can act on its own and adapt during an attack.

The practical version of this is red teaming AI systems the way a penetration tester tests a network. That means testing whether a model can be manipulated through prompt injection and whether an agent’s runtime defenses hold once it’s actually wired into production tools. Anthropic’s own disclosures this year describe autonomous agents attacking targets nobody instructed them to attack. Most job descriptions haven’t caught up to that yet.
Program and IT managers need to run the full AI lifecycle, not just the launch. Most technology leaders were trained to manage a system from procurement through launch and consider the job largely finished at that point. AI doesn’t hold still that way.

Design and requirements, build and integration, deployment and change management, and incident response when something breaks all have to run as one continuous cycle because the system keeps changing after it ships. A manager who can run that whole loop is worth more right now than one who can only run the handoff.

Risk and compliance professionals need real fluency in AI governance and, specifically, in responsible AI and ethics treated as a discipline with its own evidence standard rather than as a checkbox bolted onto an existing audit. That means learning to score AI specific risk, including technical, fairness, operational, and emergent risk, against a maturity scale rather than treating it as a yes or no question.

It also means learning one methodology that maps across the frameworks companies actually get judged against: NIST’s AI risk framework, ISO’s AI management standard, the EU AI Act, and sector regulators, each using its own vocabulary for what is often the same underlying control. A risk officer who can walk into any of those conversations without starting from scratch is the difference between governance that survives an audit and governance that only survives a slide deck.

If you can’t tell me, right now, what your AI systems did in the last hour and why they were allowed to do it, you don’t have an AI program. You have a liability with good marketing.

And if the three people who’d need to answer that question, your security lead, your program manager, and your risk officer, haven’t been trained to actually answer it, the gap isn’t the technology. It’s talent, and talent is the faster problem to fix.

The treaty conversation will keep running in the background, and it should. People who work in arms control full time are better positioned than I am to carry that debate forward. But it’s not the conversation that decides whether your company has a governance failure next quarter.

That one comes down to whether the agents already running inside your business operate within a harness someone can see and are monitored by people trained to watch them, or whether they operate outside one, quietly, until the incident report explains what happened after the fact instead of before it.
There’s a harder version of this question waiting beyond the one I’ve answered here. If the capability gains Amodei described keep compounding the way he says they are, governance itself may need to be rethought from the ground up. The question will no longer be just who’s watching the agent, but what oversight even means once a system can improve itself faster than any team can review it.

That’s a different piece, and it’s coming next.

The post What the Nuclear Treaty Got Right, and Why AI Still Can’t Use It appeared first on CISO MAG | Cyber Security Magazine.

With autonomous AI agents already reaching into government systems and no global treaty in sight, EC-Council will assist any public authority that asks to map ADG 2.0’s 180+ controls to its own laws and standards

TAMPA, Fla., October 1, 2026: EC-Council today released ADG 2.0, the second version of its Adopt, Defend, Govern framework, with crosswalks to more than 90 regulations, standards, and global frameworks at no cost to any government, regulator, or standards body in the world. EC-Council will also assist any government, regulator, or standards body that reaches out, helping officials apply ADG 2.0 to their own laws, draft rules, and national standards, consistent with applicable law.

The offer comes as governments split on how to govern AI. President Trump has said concerns about AI risks are being exaggerated. China’s Foreign Ministry said that fearmongering, confrontation, and vicious competition would hamper sound global AI governance, and on September 26, Singapore’s Foreign Affairs Minister Vivian Balakrishnan urged the UN General Assembly to establish new multilateral rules, suggesting a UN Framework Convention on AI Safeguards.

Meanwhile, autonomous agents are already crossing boundaries. In July, OpenAI disclosed that models undergoing an internal cybersecurity evaluation had circumvented their testing environment and compromised parts of Hugging Face’s production infrastructure. Last week, Australia’s Prime Minister said an OpenAI agent had gained unauthorized access to a public-facing Medicare statistics portal in June. OpenAI also confirmed its agents had accessed U.S. government websites in ways it neither planned nor approved and paused training of its latest models. Separately, an independent research lab also reported a failed attempt against a Department of Education website.

“The nuclear non-proliferation treaty worked because inspectors could weigh uranium,” said Jay Bavisi, Founder, Chairman and Group CEO, EC-Council. “You can’t weigh an agent’s behavior, and no AI treaty will be signed and ratified in time to protect the systems agents are reaching today. Governments shouldn’t have to build governance from a blank page while they wait. ADG 2.0 is open, it’s already mapped to the rules they’re working with, and we’ll sit down with any government, regulator, or standards body that wants help putting it to work.”

ADG 2.0 replaces the original 12 minimum controls with more than 180 controls in 12 control families, mapped to more than 90 regulations, standards, and frameworks, including NIST AI RMF, ISO/IEC 42001, and the EU AI Act. For a regulator, the crosswalks show how a proposed national rule lines up against what other jurisdictions already require. For an enterprise, they mean working on one control set and showing how that work satisfies every rulebook it answers to, even as those rulebooks diverge.

“Most AI governance today is a policy document nobody tests,” Bavisi said. “ADG 2.0 asks for something harder. Say what you do, do what you say, and be able to prove both on any given day. That’s what a regulator, an insurer, or a board will ask for after the next incident. There will be a next incident.”

ADG is stewarded by EC-Council’s 35-member AI Advisory Board, comprising practitioners who build, secure, transform, and govern AI across some of the world’s leading organizations such as Salesforce, ServiceNow, Azure, Microsoft, Citi, JPMorgan Chase, NTT DATA, Jio Platforms, BNP Paribas Wealth Management, and others.

The framework includes:

• 180+ controls in 12 control families. One catalog covering what needs to be governed across the AI life cycle, from design and data through runtime monitoring, incident response and third-party risk.
• Mappings to 90+ regulations, standards, and frameworks. Crosswalks to sources including NIST AI RMF, ISO/IEC 42001, the EU AI Act, MITRE ATT&CK, MITRE ATLAS, the OWASP Top 10 for LLM Applications, and the OWASP Agentic Top 10.
• Runtime governance. Controls at four points in how an AI system operates, ADMIT, DECIDE, EMIT, and COMMIT, with human approval required at defined decision thresholds.
• Tiered autonomy. Assistive, Conditional, and Autonomous levels set out what an AI system may do at each level, when a human must review, and what evidence must be kept.
• Defined evidence requirements. Each control specifies the evidence it must produce, so organizations collect it while systems run rather than assemble it before an audit.
• DART implementation method. Discover, Analyze, Report, and Transform takes an organization from finding governance gaps to closing them.

Governments, regulators, and standards bodies can request assistance at adg@eccouncil.org

The ADG 2.0 framework, crosswalks, and AI Readiness Self-Assessment are available free to everyone, without registration, at AI Governance Framework (ADG) | Enterprise Agentic AI Controls

About EC-Council

Founded in 2001, EC-Council is a global cybersecurity and AI organization. It created the Certified Ethical Hacker (CEH) program and has certified more than 400,000 professionals across 174 countries. Its credentials are used across government, defense, enterprise, and academia.

As an ISO/IEC 17024 accredited certification body, EC-Council’s credentials are recognized by the U.S. Department of Defense under DoD 8140 and are held by professionals across the U.S. Army, Navy, and Air Force.

The EC-Council ecosystem includes EC-Council, EC-Council University (ECCU), CodeRed, EC-Council Global Services (EGS), EC-Council Academia, and AwareX.

Website: www.eccouncil.org

Media Contact: press@eccouncil.org

About the ADG Framework

EC-Council’s Adopt, Defend, Govern (ADG) framework is a practitioner-led operating model for AI governance. Its three pillars connect board level oversight with operational and technical controls across the AI life cycle. ADG 2.0 contains more than 180 controls in 12 control families, with crosswalks to more than 90 regulations, standards, and frameworks. It is stewarded by EC-Council’s 38 member AI Advisory Board and supported by readiness assessments and implementation guidance. Each AI Advisory board member serves in their personal capacity, and organizations are listed purely for identification. The framework, crosswalks, white paper, and self-assessment are available openly without registration or licensing requirements.

The post EC-Council Releases ADG 2.0 and Offers Its AI Governance Crosswalks Free to Every Government, Regulator, and Standards Body as Nations Split on AI Rules appeared first on CISO MAG | Cyber Security Magazine.

Organizations often struggle to enforce security and compliance requirements consistently across their cloud infrastructure. In one environment, a workload might be deployed in an AWS Region that was never approved for that class of data. In another, a security group might allow broader access than intended. Required tags might be missing. Encryption might be assumed but not configured. These gaps create risk, increase review effort, and make audits harder than they need to be.

Many organizations already have standards that describe what good infrastructure looks like. The more difficult problem is making sure those expectations are checked the same way across repositories, environments, and teams before infrastructure is deployed. Manual review helps, but it doesn’t scale when delivery moves faster and more teams provision infrastructure directly.

Policy as code helps address this problem. It turns control intent into preventive checks that run in delivery workflow.

A pattern-based policy model makes those checks more straightforward to review, maintain, and explain. Teams can organize policy checks around recurring control patterns such as required metadata, allowed configuration, exposure restriction, protection enforcement, and privilege constraint, as shown in Figure 1. This structure simplifies policy coverage across security, governance, risk, and compliance (GRC), and engineering teams.

This post shows you how to use Open Policy Agent (OPA) in continuous integration and continuous delivery (CI/CD) pipelines to validate Amazon Web Services (AWS) infrastructure changes before deployment. You will learn how to structure policy checks around recurring control patterns, fit those checks into a gated delivery workflow, and retain validation artifacts that support both release decisions and later audit review.

The Compliance Engineering and Automation team from AWS Security Assurance Services (AWS SAS) frequently helps customers implement policy as code as part of broader control design and compliance automation efforts. This post focuses on the pre-deployment layer. Runtime monitoring and post-deployment controls still matter, but they are outside the scope of this article.

Figure 1: Pattern-based policy as code in a gated delivery workflow

Teams sometimes build rules one service at a time, which can make policy as code libraries difficult to review and extend as the library grows. Similar control requirements can be expressed differently across repositories, and teams lose a common way to discuss what the policies are enforcing.

A pattern-based approach organizes policies around recurring control intent rather than service-specific checks, as shown in Figure 2. This makes coverage more straightforward to review, explain, and evolve as infrastructure changes.

A practical set of patterns includes:

• Required metadata – for tags and other fields used for ownership, support, cost allocation, and automation.
• Allowed configuration – for approved Regions, accepted deployment boundaries, and other approved settings.
• Exposure restriction – for configurations that make infrastructure more reachable than intended, such as public ingress or internet-facing resources in the wrong environment.
• Protection enforcement – for baseline safeguards such as encryption, logging, or deletion protection.
• Privilege constraint – for AWS Identity and Access Management (IAM) definitions and access patterns that need tighter validation.

Figure 2: Recurring control patterns used to organize policy as code checks

This post focuses on the preventive layer. You still need runtime controls, drift monitoring, remediation workflows, and compliance reporting. On AWS, AWS Organizations, AWS Control Tower, AWS Config, and AWS Security Hub remain important after resources exist.

OPA fits earlier in the process and validates that infrastructure changes align with expectations. OPA evaluates structured input (HashiCorp Terraform plan JSON) against policy logic. It doesn’t replace AWS governance services that provide organizational guardrails, continuous monitoring, and resource level enforcement after resources exist.

As shown in Figure 3:

• OPA – Checks proposed changes before deployment
• AWS Organizations and Control Tower – Establish organizational guardrails
• AWS Config and Security Hub – Provide visibility and monitoring after resources exist
• Service-level protections – Enforce settings at the resource boundary

Figure 3: OPA validates changes pre-deployment; AWS services enforce guardrails, monitoring, and controls post-deployment

Use the following steps to integrate OPA policy evaluation into your delivery workflow:

Submit a change through a pull request or merge request.

1. Run early validation checks such as formatting, syntax validation, and dependency checks.
2. Generate a Terraform plan and convert it to JSON format.
3. Evaluate the plan (JSON format) against the shared OPA policy library.
4. Publish the validation report as an artifact.
5. Run additional automated quality checks as needed.
6. Use the validation artifact during approval decisions for higher-risk environments.
7. Deploy approved changes.
8. Continue post-deployment monitoring through AWS-native governance services.

Quality gates provide automated pass or fail results based on defined criteria. Approval gates control whether a change moves into a protected environment. This separation matters—manual approval isn’t the first place where anyone notices missing tags, a disallowed AWS Region, or public ingress. Automated checks identify those issues earlier. OPA belongs in the automated gate layer. Its output also feeds the approval process.

A pattern-based library structure, as shown in the following sample, keeps the policy model closer to how teams talk about controls.

  opa-policies/
  ├── patterns/
  │ ├── baseline/ # Foundational security
  │ ├── tagging/ # Required tags
  │ ├── networking/ # Network controls
  │ ├── logging/ # Logging enablement
  │ ├── encryption/ # Encryption at rest and transit
  │ └── iam/ # IAM best practices
  ├── shared/
  │ ├── helpers.rego
  │ └── messages.rego
  ├── tests/
  ├── fixtures/
  └── docs/

A compliance engineer might describe a requirement as mandatory metadata. A cloud engineer might describe the same requirement as a tagging standard. The pattern structure helps both teams talk about the same thing.

This example demonstrates the protection enforcement pattern for Amazon Simple Storage Service (Amazon S3). The goal is to verify that S3 bucket access is protected in transit by requiring a bucket policy that denies requests when aws:SecureTransport is set to false.

The policy checks two things: whether an S3 bucket policy includes a deny statement that blocks non-encrypted requests, and whether an S3 bucket has any corresponding bucket policy at all. The rule evaluates both create and update actions in the Terraform plan JSON.

This example uses an explicit deny rather than an allow statement for secure transport. An explicit deny overrides allow statements that might exist elsewhere in the policy set, making it the stronger enforcement pattern.

package compliance.amazon_s3.ssl

import future.keywords.in
import future.keywords.contains
import future.keywords.if

# Deny: S3 bucket policy missing SecureTransport deny statement
deny contains msg if {
    resource := input.resource_changes[_]
    resource.type == "aws_s3_bucket_policy"
    is_create_or_update(resource.change.actions)

    policy_value := resource.change.after.policy
    policy := json.unmarshal(policy_value)

    not has_secure_transport_deny(policy)

    msg := sprintf(
        "[S3-OPA-1] Resource '%s' does not enforce SSL/TLS. Bucket policy must include a Deny statement with Condition Bool aws:SecureTransport set to \"false\".",
        [resource.address]
    )
}

# Deny: S3 bucket created without any corresponding bucket policy
deny contains msg if {
    resource := input.resource_changes[_]
    resource.type == "aws_s3_bucket"
    is_create_or_update(resource.change.actions)

    bucket_name := resource.change.after.bucket
    not has_bucket_policy(bucket_name)

    msg := sprintf(
        "[S3-OPA-1] Resource '%s' (bucket '%s') has no bucket policy. A bucket policy with a Deny statement for aws:SecureTransport \"false\" is required.",
        [resource.address, bucket_name]
    )
}

is_create_or_update(actions) if { actions[_] == "create" }
is_create_or_update(actions) if { actions[_] == "update" }

has_bucket_policy(bucket_name) if {
    bp := input.resource_changes[_]
    bp.type == "aws_s3_bucket_policy"
    is_create_or_update(bp.change.actions)
    bp.change.after.bucket == bucket_name
}

has_secure_transport_deny(policy) if {
    stmt := policy.Statement[_]
    stmt.Effect == "Deny"
    stmt.Condition.Bool["aws:SecureTransport"] == "false"
    stmt.Principal == "*"
    action := stmt.Action
    action == "s3:*"
}

When you adapt this example, decide whether you want to require one exact policy shape or support several equivalent forms of enforcement. A strict rule is more straightforward to reason about, but it might create false positives if teams already use alternate policy structures that achieve the same outcome.

This example implements the exposure restriction pattern. The goal is to identify Amazon Virtual Private Cloud (Amazon VPC) security group configurations that allow public ingress on sensitive ports before those rules are deployed.

The policy evaluates both inline aws_security_group ingress rules and standalone aws_security_group_rule resources, because customer repositories often use both modeling styles.

This example checks directly for public ingress on sensitive ports rather than trying to infer whether later controls might reduce actual exposure. Security group rules are a direct expression of intended network reachability, making them the right place to enforce this pattern early.

package compliance.amazon_vpc.ingress

import future.keywords.in
import future.keywords.contains
import future.keywords.if

# Sensitive ports that must not be open to the internet
sensitive_ports := {22, 3389, 5432}

# Deny: aws_security_group with inline ingress open to 0.0.0.0/0 on sensitive ports
deny contains msg if {
    resource := input.resource_changes[_]
    resource.type == "aws_security_group"
    is_create_or_update(resource.change.actions)

    ingress := resource.change.after.ingress[_]
    ingress.cidr_blocks[_] == "0.0.0.0/0"

    port := sensitive_ports[_]
    ingress.from_port <= port
    ingress.to_port >= port

    msg := sprintf(
        "[VPC-OPA-1] Resource '%s' allows ingress from 0.0.0.0/0 on port %d. Restrict access to specific CIDR ranges.",
        [resource.address, port]
    )
}

# Deny: aws_security_group_rule with type "ingress" open to 0.0.0.0/0 on sensitive ports
deny contains msg if {
    resource := input.resource_changes[_]
    resource.type == "aws_security_group_rule"
    is_create_or_update(resource.change.actions)

    resource.change.after.type == "ingress"
    resource.change.after.cidr_blocks[_] == "0.0.0.0/0"

    port := sensitive_ports[_]
    resource.change.after.from_port <= port
    resource.change.after.to_port >= port

    msg := sprintf(
        "[VPC-OPA-1] Resource '%s' allows ingress from 0.0.0.0/0 on port %d. Restrict access to specific CIDR ranges.",
        [resource.address, port]
    )
}

is_create_or_update(actions) if { actions[_] == "create" }
is_create_or_update(actions) if { actions[_] == "update" }

When you adapt this example, review which ports to treat as sensitive, whether both IPv4 and IPv6 exposure need checking, and how to handle approved exceptions.

This example implements the privilege constraint pattern for IAM role trust policies. The goal is to identify trust relationships that allow overly broad principals to assume a role. The policy inspects the assume_role_policy document for aws_iam_role resources and looks for wildcard principals in three valid representations: Principal is "*", Principal.AWS is "*", and Principal.AWS is an array containing "*". A wildcard principal allows a broader set of callers than most environments intend to permit. By treating wildcard principals as the prohibited pattern, the rule enforces a safer default and returns a clear result that reviewers can understand quickly.

package compliance.amazon_iam.trust

import future.keywords.in
import future.keywords.contains
import future.keywords.if

# Deny: IAM role with wildcard principal in trust policy
deny contains msg if {
    resource := input.resource_changes[_]
    resource.type == "aws_iam_role"
    is_create_or_update(resource.change.actions)

    policy_value := resource.change.after.assume_role_policy
    policy := json.unmarshal(policy_value)

    stmt := policy.Statement[_]
    stmt.Effect == "Allow"
    has_wildcard_principal(stmt)

    msg := sprintf(
        "[IAM-OPA-2] Resource '%s' has a wildcard principal in its trust policy. Specify explicit account ARNs, service principals, or federated providers instead of \"*\".",
        [resource.address]
    )
}

# Principal is directly "*"
has_wildcard_principal(stmt) if {
    stmt.Principal == "*"
}

# Principal.AWS is "*"
has_wildcard_principal(stmt) if {
    stmt.Principal.AWS == "*"
}

# Principal.AWS is an array containing "*"
has_wildcard_principal(stmt) if {
    stmt.Principal.AWS[_] == "*"
}

is_create_or_update(actions) if { actions[_] == "create" }
is_create_or_update(actions) if { actions[_] == "update" }

When you adapt this example, decide what least privilege means for your IAM trust model. The key design choice is whether your policy checks for a single prohibited pattern or validates trust relationships against an approved set of trusted principals and conditions.

AWS Labs provides IAM Policy Autopilot, an open-source Model Context Protocol (MCP) server and command-line tool that helps generate baseline identity-based IAM policies from application code. That is adjacent to the pattern shown here —IAM Policy Autopilot helps with policy generation, while this example focuses on validating whether IAM role trust policies are scoped appropriately in infrastructure changes.

The following examples show the same operating model in two common CI/CD systems. The syntax changes, but the sequence stays the same: validate, plan, evaluate policy, retain the artifact, and use the result during promotion and approval. These examples assume OPA is installed in your CI/CD environment, the opa-policies directory contains your policy library, and Terraform is configured with appropriate credentials.

GitLab CI

stages:
  - validate
  - plan
  - policy_check

variables:
  TF_IN_AUTOMATION: "true"

terraform_validate:
  stage: validate
  script:
    - terraform fmt -check
    - terraform init
    - terraform validate

terraform_plan:
  stage: plan
  script:
    - terraform plan -out=tfplan
    - terraform show -json tfplan > tfplan.json
  artifacts:
    paths:
      - tfplan.json

opa_policy_check:
  stage: policy_check
  script:
    - opa eval --format pretty --data opa-policies --input tfplan.json "data.terraform.deny"
    - opa eval --format json --data opa-policies --input tfplan.json "data.terraform.deny" > policy-report.json
  artifacts:
    paths:
      - policy-report.json

GitHub Actions

name: Terraform Policy Check
on:
  pull_request:

jobs:
  policy-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3

      - name: Terraform Format Check
        run: terraform fmt -check
      - name: Terraform Init
        run: terraform init
      - name: Terraform Validate
        run: terraform validate
      - name: Terraform Plan
        run: terraform plan -out=tfplan
      - name: Convert Plan to JSON
        run: terraform show -json tfplan > tfplan.json
      - name: Run OPA Policy Check
        run: |
          opa eval --format pretty --data opa-policies --input tfplan.json "data.terraform.deny"
          opa eval --format json --data opa-policies --input tfplan.json "data.terraform.deny" > policy-report.json
      - name: Upload Validation Artifact
        uses: actions/upload-artifact@v4
        with:
          name: policy-report
          path: policy-report.json

In mature delivery workflows, policy results don’t disappear into pipeline logs but are retained as validation artifacts. Those artifacts help reviewers decide whether a change is ready for approval, supports exception handling by showing which controls failed and why, and can stay with the change record for later audit discussions. At a minimum, the artifact identifies the change or pipeline run, the evaluated scope, the policy package or version, the checks that ran, and the pass or fail results.

The first few rules are usually straightforward.The real work starts when the library grows and multiple teams depend on it. Testing includes:

• Positive and negative test cases – Each policy has cases that show valid input and cases that show expected failures.
• Regression coverage – Shared helpers need regression coverage.
• Realistic fixtures – Terraform plan fixtures look like real changes rather than tiny made-up samples.
• Impact analysis – When a rule changes, teams can tell quickly what else might be affected.

If developers stop trusting the results, they stop treating policy as a useful mechanism.

You don’t need broad coverage on day one. A phased rollout works better than an all at once enforcement approach.

Phase 1: Assess and pilot

• Start in advisory mode so teams can see results without being blocked.
• Identify two or three high-confidence patterns such as required metadata, approved Regions, or public exposure restrictions.
• Run OPA against existing pipelines and review the output for accuracy.

Phase 2: Begin enforcement

• Enforce the small set of high-confidence patterns after the output is stable and the failures are useful.
• Integrate validation artifacts into your approval workflow.
• Establish ownership and exception handling processes for shared packages.

Phase 3: Operationalize and expand

• Formalize versioning for shared policy packages.
• Expand pattern coverage based on team feedback and organizational priorities.
• Connect pre-deployment validation with post-deployment monitoring through AWS Config, AWS Security Hub, and AWS Organizations.

Policy as code helps narrow the distance between what an organization says it expects and what its delivery system checks. By implementing these OPA patterns in your CI/CD pipelines, you can build a preventive layer that evaluates infrastructure changes before deployment. With a pattern-based library, validation artifacts, and clear ownership, policy as code becomes a repeatable way to help translate control intent into day-to-day delivery, while AWS governance services continue to provide visibility and monitoring after resources exist.

To learn more about policy as code and AWS governance capabilities, see:

• Contact AWS Security Assurance Services – Get help with your compliance engineering journey
• Open Policy Agent Documentation – Read the official OPA documentation and policy language reference
• AWS Security Hub User Guide – Learn how to aggregate and prioritize security findings
• AWS Well-Architected Framework: Security pillar – Review security best practices for your workloads
• AWS Config Developer Guide – Learn how to monitor and record resource configurations
• IAM Policy Autopilot – An open source command line interface (CLI) and MCP server from AWS Labs that helps generate IAM policies

If you have feedback about this post, submit comments in the Comments section below.

Key Takeaways

• Built on the Pioneers of PAM (privileged access management): Idira is Palo Alto Networks next-generation identity security platform, extending privileged access controls to every human, machine and AI agent identity in the AI enterprise.
• Zero Standing Privilege by Default: Idira replaces static, always-on access with dynamic privilege, granted just-in-time on a single control plane.
• AI-Driven Identity: AI runs natively inside Idira to surface hidden entitlements, unmanaged accounts, recommend least privilege, and remediate to close the gap between attackers who move in 72 minutes and defenders who historically took days.

Since Palo Alto Networks and CyberArk came together in February, customers have been asking me the same question: What does the future of identity security actually look like?

At IMPACT, I got to answer that question.

I am proud to introduce Idira, the next-generation identity security platform from Palo Alto Networks. Idira secures every identity in the AI enterprise (human, machine, AI agent) on a single control plane that discovers risk, applies privilege dynamically, and governs the full lifecycle from first access to last session.

Idira begins with a belief shaped by more than 20 years of working on this problem. Privilege is the most challenging aspect of identity security. For a generation, the industry learned how to manage it well for a small population – administrators inside the most security-sensitive organizations in the world. That was necessary. But it is no longer enough.

The moment has come to extend that same rigor to every identity, because every identity today carries the power to move the business, or enable an attacker. That is the journey Idira takes us on. From privilege controls for administrators, to privilege controls for every identity.

Attackers Are Not Breaking In. They Are Logging In.

For most of the last two decades, identity security was built on a comfortable assumption: One can maintain a firm divide between a small number of powerful administrators and a much larger number of ordinary users; that is enough to secure the organization. That assumption no longer holds.

Our Chairman and CEO, Nikesh Arora, calls it the “IAM fallacy,” and the data in the 2026 Identity Security Landscape Report makes clear why it is time to retire this assumption.

Based on responses from 2,930 cybersecurity decision-makers worldwide:

• Machine identities now outnumber humans by 109 to 1. Of those, 79 are AI agents.
• 91% of organizations already run autonomous agents in production.
• 90% of organizations suffered an identity-related breach in the past 12 months. 83% of organizations suffered two or more incidents.

The old model is not failing because identity became less important. It is failing because identity and privilege became universal and ubiquitous.

Every major breach I have studied over the last two years follows the same pattern. An attacker steals a credential. They move laterally using standing access that should have expired. They escalate privilege. They reach the data, the infrastructure or the business systems they came for: Okta, MGM, Microsoft. Different industries. Different scales. The same pattern.

One overprivileged identity unlocks the entire enterprise.

And when defenders have a chance to respond, they are already behind and disadvantaged. 97% of practitioners tell us that fragmented tools add 12 hours to every identity incident response time. All while Unit 42^® has observed the fastest attackers move from a first foothold to exfiltration in as little as 72 minutes.

Identity is now the enterprise perimeter. And the perimeter was built for a threat model that no longer exists.

Every Identity Is Privileged — Idira’s First Fundamental Principle

The premise of Idira is simple. Every identity in your organization is privileged.

Every login, every token, every service account, every workload, every AI agent can trigger a workflow, call an API, or reach sensitive data. Some can create and destroy infrastructures, direct organizational spend, or create new identities. Privilege is no longer reserved for a small class of administrators. It is distributed across the enterprise, quietly and continuously, every second of the day.

The controls that protect privilege cannot be reserved for the few, either.

Idira changes three things from day one.

First, We Discover

Idira continuously finds every identity, every entitlement and every access path across your entire environment: humans, machines, workloads, secrets, certificates and AI agents everywhere – on the network, in the cloud, on servers and endpoints, in the browser. If someone or something can authenticate, Idira knows it is there, knows what it can reach, and evaluates how much of that access is actually necessary.

Second, We Control

Idira replaces static, always-on accounts attackers rely on with dynamic privileges that exist only in the moment of use. Zero standing privilege moves from aspiration to default, and it applies equally to the administrator logging into production, the developer deploying code, and the AI agent calling a tool. This is the shift to identity-centric active security.

Third, We Govern

Idira automates the identity lifecycle end-to-end. Governance stops being a quarterly compliance exercise and becomes a continuous enforcement loop. The 12-hour fragmentation tax closes.

This is what I mean when I say we are democratizing privilege controls. We are not loosening them. We are extending the strongest privilege controls the industry has ever built to every identity that now carries the weight of the business, without penalizing these identities for the powers they carry.

Already Better Together

Idira is not launching into an empty runway. We have been executing against this roadmap since the day we joined Palo Alto Networks, and the early results give us real confidence in what comes next.

Earlier this year at the RSA Conference, we launched Next-Generation Trust Security (NGTS), the first network-native platform to automate certificate lifecycle management and accelerate post-quantum readiness. That matters because 71% of organizations have not yet automated certificate renewal. As public TLS lifetimes compress to 47 days and manual workloads multiply, that gap becomes more than an operational burden. It becomes a business continuity risk.

NGTS closes it in the network itself.

As one of the core platforms of Palo Alto Networks along with Strata^® and Cortex^®, Idira is providing deep identity integrations across the entire portfolio to enhance platform value for customers. Prisma^® Browser delivers privileged access directly in the place where enterprise users work. Prisma AIRS 3.0 natively integrates with Idira to extend deep identity security and privilege controls to AI agents. Cortex will receive first-party identity signals to sharpen detection and take automatic identity- and privilege-driven response actions when indicators of compromise are detected.

Customers are already seeing the impact. Northern Trust improved password compliance by 137 percent. Panasonic Information Systems rebuilt its security operations around identity. Healthfirst grounded its zero trust program in identity-first controls. PDS Health secured clinical access for more than 900 practices. They had different problems with the same answer.

Different challenges. One answer. One platform. Consistent privilege controls applied to every identity that matters.

AI Makes This Urgent. AI Makes This Possible.

AI has changed the speed, scale and economics of identity risk.

Frontier models have crossed a threshold. Anthropic's Claude Mythos Preview has already identified thousands of zero-day vulnerabilities across the operating systems and browsers that businesses rely on every day. Every exposed secret, every standing admin path, every forgotten service account can now be discovered, validated and weaponized faster than most security teams can respond. 55% of the decision-makers in our 2026 survey named AI-enabled threats as their top identity concern.

Our answer is clear: We fight AI with AI.

If frontier models are rewriting the economics of attack, the only credible response is to rewrite the economics of defense with the same technology.

Idira is how we do that in identity. AI is built into the platform to surface hidden entitlements, identify risky access combinations, recommend the least privilege automatically, and drive surgical remediation. That same intelligence lets attackers find the weakest link in 72 minutes and helps defenders close it in seconds.

When code cannot be patched fast enough, identity becomes the control plane that can still adapt at machine speed.

Same Mission, Stronger Together

For more than two decades, the pioneers of privileged access have management-built controls trusted to safeguard the world's most critical environments. That mission created a category and earned the trust that made today possible.

Idira carries that mission forward and expands it to match the scale of the problem we now face.

This is the first wave, not the last. The roadmap extends privilege controls to workforce identity, advances machine and agentic identity security, and unifies a fragmented market into one platform. We are building it in the open, shaped by the customers in the room with us at IMPACT and by the realities they face every day.

The future of identity security will not be defined by access alone. It will be defined by control. See what Idira is built to deliver.

This blog contains forward-looking statements that involve risks, uncertainties and assumptions, including, without limitation, statements regarding the benefits, impact, or performance or potential benefits, impact or performance of our products and technologies or future products and technologies. Any unreleased services, integrations or features (and any services or features not generally available to customers) referenced in this or other press releases or public statements are not currently available (or are not yet generally available to customers) and may not be delivered when expected or at all. Customers who purchase Palo Alto Networks applications should make their purchase decisions based on services and features currently generally available.

The post Idira — Our Journey to Democratize Privilege Controls appeared first on Palo Alto Networks Blog.

Acting swiftly with intent, together with Accenture, Deloitte, IBM, NTT DATA and PwC

With the imminent release of unbounded frontier models, the barrier to entry for sophisticated cyberattacks has vanished. Anthropic’s Mythos represents a 50% leap in coding capability over previous models. It’s a leap that, as Lee Klarich stated, translates into autonomous agents capable of both surfacing a massive surge of vulnerabilities and exploiting them faster than we’ve ever seen or imagined.

In this new era, business continuity requires more than just better tools; it requires a unified ecosystem of experts capable of orchestrating a defense that matches this new pace of attack.

As we drive the industry standard for addressing these emerging risks with our Unit 42^® Frontier AI Defense, we’ve united an alliance of global transformation leaders, starting with Accenture, Deloitte, IBM, NTT DATA and PwC, and will continue to scale these alliances to ensure every enterprise has a rapid path to AI resilience.

By combining the world’s most advanced AI security platform with deep industry expertise, we are delivering the security assessment and rapid protection needed to help customers stop emerging threats and keep their business resilient.

By engaging directly with Palo Alto Networks, or working with our partners through the Frontier AI Alliance, our customers can move past the complexity of building an AI-ready defense from scratch and gain:

• Accelerated Immunity: Go from a high-exposure state to a hardened posture using a prevalidated AI Defense Blueprint, delivering coverage in weeks, not years.
• On-Demand Expertise: Our partners provide the specialized prompting and verification required to make the latest AI Frontier models work for the defender.
• Operational Resilience: While Unit 42 provides the Frontier AI Exposure Analysis, our ecosystem partners provide the boots on the ground to remediate those findings and leverage our product portfolio to deliver AI-readiness to your enterprise.

The threat of Mythos-class models is imminent, but the path to resilience is clear. Whether you are looking for an immediate strategic assessment or a deep operational overhaul, the Frontier AI Alliance is ready to move at the speed of your business.

The post The AI Ecosystem Edge — Introducing Our Frontier AI Alliance appeared first on Palo Alto Networks Blog.

The release of the newest frontier AI models marks a turning point for cybersecurity. Palo Alto Networks has conducted early testing of the latest frontier AI models, including Anthropic’s Mythos model as part of Project Glasswing and OpenAI’s latest models as part of Trusted Access for Cyber program. The conclusion is clear: They are extraordinarily capable at finding vulnerabilities and generating corresponding exploits.

This generational improvement in coding ability directly translates to a significant advance in vulnerability discovery and exploit generation. These capabilities, however guardrailed, will not stay contained. Similar advances will appear across other major AI labs, Chinese models, and open source models. Attackers will find the seams in those guardrails. They will use advanced AI to discover zero-day vulnerabilities at scale, generate exploits in near real time, and develop autonomous attack agents unlike anything the industry has faced.

Within six months, advanced AI models with deep cybersecurity capabilities will become commonplace. Organizations that have not put appropriate safeguards in place will face an entirely new class of risk across their enterprise and critical infrastructure.

Frontier AI: A Quantum Leap in Code Fluency

As you have probably already seen, the latest unbounded models like Mythos represent roughly a 50% improvement in coding efficiency over Anthropic’s previous leading model. Palo Alto Networks has had early access to unbounded models and we’ve been able to leverage this vast improvement in coding to a quantum leap in scanning and offensive capability.

Hundreds of our best security engineers have been assessing these capabilities and developing best practices for using it effectively. The results revealed several core truths:

• Vulnerability discovery at scale: Frontier AI is exceptionally effective at identifying vulnerabilities in code. In less than three weeks, it accomplished the equivalent of a full year’s worth of penetration testing effort.
• Attack path determination: Perhaps more impressive than finding individual vulnerabilities, Frontier AI excels at vulnerability chaining, combining multiple lower-severity issues into critical-level exploit paths. For example, linking two medium-severity and one low-severity vulnerability into a single critical exploit.
• Full-stack logic analysis: Frontier AI can analyze the full exposure surface of applications, including SaaS and public-facing platforms, identifying logic-based vulnerabilities that traditional tools miss.

Impacts on the Cyber Landscape

Attackers have been using LLMs for years, but based on our testing of frontier AI models, there are three key areas where they will have a significant impact on the cybersecurity landscape:

1. The Vulnerability Deluge: Frontier AI models will dramatically accelerate the rate at which vulnerabilities are discovered, by defenders and attackers alike. This will be particularly acute in open source and critically, the flood of patches that follows will itself create risk. Every patch that is not applied immediately becomes a known, targetable vulnerability. Organizations will need to accelerate and automate their patching programs, rethink how they prioritize and apply patches, and ensure best-in-class protections are in place to mitigate vulnerability until they can be remediated.
2. Rise of Inside-Out Attacks: Recent supply chain attacks on tools like LiteLLM and Trivy demonstrate a growing pattern where attacks land adversaries inside an organization’s infrastructure, bypassing multiple conventional attack steps and reducing the number of prevention opportunities available to defenders. The rapid deployment of AI infrastructure has made this problem more acute as the AI supply chain, including runtime environments, communication infrastructure, and model dependencies, is often insufficiently protected. While open source usage and patching practices must become significantly more robust, organizations will need structural containment of potential attacks through zero trust, identity modernization, outbound connection restrictions and lateral movement protections.
3. Faster AI-Assisted Attack Cycles: I expect the most consequential shift with frontier AI models is the move from AI-assisted to AI-driven attacks. Attackers will build autonomous attack agents that dramatically compress attack cycle times. What once took days or weeks of skilled manual effort will soon be executed in minutes. This democratization of advanced attack capabilities means that defenders must match that speed with near-real-time detection and response, which is only possible with extensive AI and automation throughout security operations. Organizations whose Mean Time to Detection and Mean Time to Response are not measured in low single-digit minutes will be outpaced.

The Defenders Guide: Assessment, Protection, Platformization

The framework for defending against AI-driven threats is not completely new, but the standard for execution must be absolute. Organizations that are “mostly protected” are effectively unprotected. What follows is a phased approach – assessment, protection and platformization – that organizations should pursue in parallel to close gaps before attackers exploit them.

Assessment: Every organization should use the latest AI models to assess its entire code and application landscape and build a comprehensive asset and exposure inventory.

Key priorities:

• Leverage AI models to identify vulnerabilities across your codebase, applications and infrastructure before attackers do.
• Evaluate exposure with full context, including how vulnerabilities chain together to form critical exploit paths.
• Audit your open source supply chain, including AI infrastructure, runtime environments and model dependencies.
• Map your current sensor coverage. Detection, prevention and telemetry gaps represent critical blind spots.

Protect & Remediation: Remediating and reducing exposure is table-stakes. What in the past may have been difficult due to cross-organizational friction of finding and fixing at pace should now be accelerated with the c-suite attention of these new AI models. But this must go further and extend to comprehensive deployment of best-in-class attack prevention capabilities where the new standard is 100% coverage and optimization.

• XDR everywhere, with emphasis on real-time ML-based detection and prevention of attacks; all hosts on prem and cloud included.
• Agentic endpoint security to secure wide-scale adoption of vibe coding and AI security across the enterprise (e.g. Prisma AIRS and our recent acquisition of Koi is now a necessity for securing the agentic endpoint).
• With an average of 85% of work now happening in the browser, secure enterprise browsers with real-time security become a must-have for attack prevention.
• Zero trust and identity security are foundational to securing every user and every connection.

Real-Time Security Operations: With attack cycle times shrinking rapidly, the legacy approach to security operations simply doesn’t work. Disparate tools analyzing data in silos overlaid with manual processes must be replaced with AI and automation throughout. Cortex XSIAM, our AI-driven SOC platform, is what I consider to be the gold standard for how to take a next-generation approach to deliver MTTD and MTTR in single digit minutes.

• Attack detections must be AI/ML driven to detect even frequently-changing and novel attacks at scale.
• These AI detections must operate against a wide range of 1st party and 3rd party data sources – a best in class AI SOC must operate on ALL relevant data sources.
• Automation both natively integrated and throughout the SOC lifecycle is necessary to achieve single digit MTTR; this automation will increasingly be agentic.
• This must be delivered as a platform to remove the seams and gaps between point solutions.

We’re Here to Help

Achieving this level of resilience requires the right platforms and the right expertise.

To help you navigate this shift, we are introducing Unit 42 Frontier AI Defense. This new offering is designed to discover and remediate your current exposure before attackers do, strengthen controls that reduce exposure and contain impact and modernize operations so teams can detect and respond at machine speed.

This is the moment we’ve been preparing for. The threat has never been more sophisticated, but the path forward has never been clearer, and we’re here to partner with you on what comes next.

The post Defender's Guide to the Frontier AI Impact on Cybersecurity appeared first on Palo Alto Networks Blog.

Frontier AI models have given the security industry a preview of what comes next. As they become weaponized, attackers will automate the discovery and chaining of vulnerabilities in near real-time – compressing timelines, increasing scale and outpacing human-led defense.

Until now, defenders have had time to detect activity, investigate signals and contain threats before exposures were chained into full attacks. AI is quickly closing this window.

Defending against AI-driven threats means engineering a resilient architecture that limits how easily attackers can exploit discovered weaknesses, that contains the blast radius when they do, and enables faster response at scale. It also means using AI to accelerate the security program itself, from vulnerability discovery and code review to triage, remediation and incident response.

The transition should cover three areas. First, discover and remediate your current exposure before attackers do. Second, strengthen controls that reduce exposure and contain impact. Third, modernize operations so teams can detect and respond in real-time.

To help organizations make this shift, Palo Alto Networks is launching Unit 42^® Frontier AI Defense.

Powered by the latest AI models, Unit 42 Frontier AI Defense helps organizations answer a critical question: Are your defenses ready for AI-powered attacks?

Unit 42 Frontier AI Defense combines three core components delivered by expert consultants, coupled with 6 months of complimentary access to Cortex^® XDR, Cortex Xpanse^® and Koi Agentic Security.

Frontier AI Exposure Analysis: Identify and validate the exposures most likely to be chained into real attacks before attackers weaponize them.

Actions

• • Use the latest frontier models, Unit 42 offensive security expertise, threat telemetry and Unit 42 Threat Intelligence to assess your environment.
  • Identify the vulnerabilities, misconfigurations and posture gaps most likely to be exploited across infrastructure, applications, code, identity and cloud.
  • Validate the attack paths most likely to matter in real-world attacks.

Outputs

• • A prioritized view of vulnerabilities and attack paths that matter most
  • Clear actions to fix the exposures that matter first

Autonomous Security Blueprint: Benchmark current capabilities and define the changes required for machine-speed defense.

Actions

• • Assess current-state capabilities across attack surface, identity, software supply chain, zero trust containment, as well as real-time detection and response.
  • Identify where AI-powered threats create the greatest exposure and where current controls are most likely to fail.
  • Define the technical and operational changes required to close those gaps.

Outputs

• • A clear blueprint for immediate action
  • A prioritized roadmap to reduce exposure, strengthen containment and modernize security for the AI era

Agentic Defense Transformation: Implement the prioritized architecture, control and operating changes needed to modernize defenses for AI-driven threats.

Actions

• • Implement the architectural, operational and control changes required to defend against AI-driven threats.
  • Modernize exposure management, harden the software supply chain, and advance zero trust architecture.
  • Build response capabilities that can keep pace with autonomous attacks.

Outputs

• • Accelerated implementation of the changes that matter most
  • A more modern security architecture, built to reduce exposure and improve containment

The Window Is Still Open, for Now

AI is the biggest security inflection point since enterprises moved to the cloud. Organizations that act now will be the ones that are ready. Those that wait will be forced to respond under maximum pressure on the worst possible day.

Frontier AI is changing what is possible for attackers. In the hands of defenders, it can become a decisive advantage.

Human-speed security is no longer enough. A modern security approach is required. Get started with Unit 42 Frontier AI Defense today.

*The complimentary offer is not available to public sector customers or current Cortex XDR, Cortex Xpanse or Koi customers.

The post Introducing Unit 42 Frontier AI Defense appeared first on Palo Alto Networks Blog.

If you have feedback about this post, submit comments in the Comments section below.

Forging Secure AI Threat Protection for Singapore

Singapore is currently undergoing a decisive transition toward an AI-enabled economy. National initiatives are focused on driving large-scale transformation through the National AI Missions and integrating advanced technologies, including generative AI and autonomous agents across key sectors. This rapid technological evolution, however, also introduces a sophisticated threat landscape characterized by AI-specific risks, like prompt injection, model manipulation and sensitive data leakage. As enterprises scale AI adoption, the need for robust, AI-native and locally hosted cybersecurity solutions becomes essential to ensure data residency, regulatory alignment and operational resilience.

Strategic Imperatives for an Emerging AI Security Landscape

Singapore’s highly integrated digital ecosystem presents both significant opportunities for leadership as well as distinct security challenges. As the nation executes its National AI Strategy 2.0, the focus has shifted from high-level experimentation to the pervasive deployment of AI across the economy. This evolution requires a security posture that is not only AI-native but locally grounded to satisfy the data residency expectations of a global financial and innovation hub.

Palo Alto Networks is pleased to announce a strategic investment designed to enhance Singapore’s cyber resilience – the establishment of our new cloud landing for Prisma^® AIRS. This launch demonstrates a commitment to providing organizations in the region with an AI-powered cybersecurity platform that aligns with the National AI Council’s whole-of-government mission. This initiative optimizes operational efficiency and facilitates the secure adoption of advanced digital transformation projects, allowing organizations to Deploy Bravely.

Comprehensive AI Security Platform

The new regional expansion in Singapore now hosts Prisma AIRS, our most comprehensive AI security platform, specifically engineered to deliver robust security across the entire AI lifecycle. This localized landing provides Singaporean organizations with domestic, high-performance access to critical AI security capabilities:

AI Model Security
Enable the safe adoption of third-party AI models by scanning them for vulnerabilities and secure your AI ecosystem against risks, such as model tampering, malicious scripts and deserialization attacks.

AI Red Teaming
Uncover potential exposure and lurking risks before bad actors do. Perform automated penetration tests on your AI apps and models using our Red Teaming agent that stress tests your AI deployments. Our agent learns and adapts like a real attacker.

AI Runtime Security
Protect your LLM-powered AI apps, models and data against runtime threats, such as prompt injection, malicious code, toxic content, sensitive data leaks, resource overload, hallucinations and more.

AI Agent SSPM (SaaS Security Posture Management)
Secure AI agents (including those built on no-code/low-code platforms) against new agentic threats, such as identity impersonation, memory manipulation and tool misuse.

Commitment to Singapore's AI Future

Our new region expansion into Singapore signifies the long-term commitment of Palo Alto Networks to the nation’s digital transformation journey and its cybersecurity resilience. By bringing advanced, AI-native platforms closer to regional organizations, Palo Alto Networks helps enterprises achieve data residency and national data sovereignty needs, enhance performance and strengthen security posture. This localized presence simplifies operations and accelerates the safe adoption of generative AI and agentic workflows.

As Singapore continues its trajectory toward an AI-driven and secure future, Palo Alto Networks stands as a trusted partner, empowering organizations to innovate and thrive securely within an evolving threat landscape. The establishment of this new cloud landing reinforces the ongoing promise to deliver the best-in-class cybersecurity platforms that the country requires to lead on the global stage.

Please visit the regional cloud locations of Palo Alto Networks for more information.

The post Announcing Prisma AIRS Availability in Singapore Region appeared first on Palo Alto Networks Blog.

A Pivotal Moment for National Security

As the digital landscape undergoes profound shifts, the recently released National Cyber Strategy provides the essential foundation for enduring American leadership. By prioritizing the disruption of hostile actors, future-proofing networks, accelerating quantum readiness, and securing the AI frontier, the strategy provides the strategic clarity necessary to protect our digital way of life from sophisticated adversaries. Palo Alto Networks commends National Cyber Director Sean Cairncross for his leadership and looks forward to working with the administration to operationalize this strategy.

Each pillar of the strategy galvanizes meaningful action to advance our collective defense:

Shape Adversary Behavior (Pillar 1)

This signals a decisive shift toward the proactive disruption of malicious actors. The Trump Administration has made clear that the U.S. Government should impose real costs on adversaries to change their behavior. While the private sector is already executing discrete disruptions against malicious actors, coordination has historically been fragmented. The strategy identifies that increased collaboration with private sector entities, who possess unique insight into adversary behavior, can in turn enable more impactful deterrence.

Promote Common Sense Regulation (Pillar 2)

The strategy appropriately recognizes that complexity is the enemy of security. A focus on measurable improvements in cyber outcomes (versus check-the-box compliance exercises) collectively makes us all safer. While much attention is rightfully paid toward harmonizing incident reporting requirements, which Palo Alto Networks wholeheartedly supports, let’s not stop there. The federal government can lead by example by consolidating and streamlining federal government software compliance certifications. For example, there should be logical reciprocity between FedRAMP High and DoW IL-5 certifications.

Modernize and Secure Federal Government Networks (Pillar 3)

In addition to the necessary attention on AI-powered cyber defense, cloud security and zero trust network architecture, Palo Alto Networks applauds the discrete focus on quantum-safe security ahead of “Q-Day,” the point where quantum computing capabilities will compromise legacy public key encryption that has underpinned cybersecurity for decades. As Federal CISO Mike Duffy recently stated, "Modernization without considering PQC readiness or cryptographic agility is really creating technical debt in the future, something that we don’t want to see ever.”

To address this challenge, Palo Alto Networks provides a structured quantum-safe framework organized into four stages:

• Continuous Discovery – Automating ecosystem ingestion to identify cryptographic dependencies.
• Risk Assessment & Prioritization – Evaluating vulnerabilities to establish a data-driven remediation roadmap.
• Comprehensive Remediation – Executing the transition to post-quantum algorithms across the architecture.
• Governance & Crypto-Hygiene – Maintaining long-term visibility and management.

The bottom line is that 2035 is too late. Quantum readiness must accelerate today, and this strategy will set a critical North Star to drive the necessary urgency.

Secure Critical Infrastructure (Pillar 4)

Critical infrastructure resilience is central to our homeland security, economic security, public health and safety. Unfortunately, critical infrastructure entities are increasingly under assault from emboldened cyber adversaries.

In fact, Palo Alto Networks research shows some form of operational disruption in up to 86% of major cyber incidents. Our 2026 Global Incident Response Report underscores another sobering reality: These entities are under assault from all angles. In 87% of cyber incidents, attacks targeted multiple attack surfaces, which spanned the network, cloud, endpoints and identity.

Recognizing that you can’t secure what you can’t see, we need a national-level effort to identify, prioritize and harden the critical infrastructure that the American people depend upon. This strategy puts an important marker in the ground to revitalize those efforts.

Sustain Superiority in Critical and Emerging Technologies (Pillar 5)

Palo Alto Networks was pleased to see the strategy reinforces the core tenets of the AI Action Plan, emphasizing that "secure-by-design" principles for AI technologies are non-negotiable and that AI adoption and AI security can and must be inexorably linked.

Enterprises should be able to deploy AI confidently without fear of data leakage, model tampering or rogue AI agents. However, despite our research showing an 88% success rate of “jailbreaking” techniques against widely deployed AI models, only 6% of organizations currently have an AI security strategy. It’s time to flip this paradigm and put defenders back in the driver’s seat in this AI-first moment.

To support this emerging consensus around the importance of promoting AI security, we developed the Secure AI by Design Policy Roadmap. This framework provides a four-part construct to evaluate the evolving dimensions of threats to AI systems. Palo Alto Networks is also proud to make its comprehensive AI security suite, Prisma^® AIRS, available to all federal agencies at substantial discounts through GSA’s OneGov Initiative.

Build Talent and Capacity (Pillar 6)

Recognizing America’s cyber workforce as a “strategic asset,” the strategy calls for a pragmatic and accessible pipeline for developing talent. The explicit recognition that we should take advantage of existing avenues across government, industry and academia is important. For example, Palo Alto Networks is proud of the impact of its Cybersecurity Academy – that provides free, NIST Framework-aligned curricula covering essential domains, such as cybersecurity fundamentals, enterprise and network security, cloud security, security operations and the AI/cybersecurity nexus.

Resources like this, and those for other entities, can form the basis of a renewed focus on cyber talent development.

Turning Strategic Vision Into Action

Palo Alto Networks views itself as more than a cybersecurity vendor. We see ourselves as an integrated national security partner of the federal government at a moment when defending our digital way of life demands all of us working together. To that end, we are ready to do our part to turn strategic vision into action.

This strategy should be applauded. Let’s roll up our sleeves and get to work.

The post How the National Cyber Strategy Secures Our Digital Way of Life appeared first on Palo Alto Networks Blog.

The Pivot to Large-Scale Intelligence

For decades, Telecommunications Service Providers have been the central nervous system of the global economy, tasked with a singular, critical mission: connecting people.

The industry spent vast amounts of capital building networks that moved voice, then text and finally high-speed mobile data. We succeeded. According to GSMA's most recent report, there are 5.8 billion unique subscriptions. The world is connected.

But the mission is changing fast. We are no longer just moving data; we are now expected to host intelligence.

Today’s enterprises are drowning in data and desperate for AI-led capabilities to analyze and process the information. They are struggling with the immense capital costs, the scarcity of GPUs, and complex data sovereignty regulations that make public cloud options difficult for sensitive workloads.

We are no longer living in the communications age, or the internet age, or the social network era, not even in the generative AI era. We are entering the Agentic Era. In this new era, data is the raw resource, and AI agents and models are the machinery that refines it into value. The infrastructure required to do this – from massive data ingestion to complex training and high-volume real-time inference – is called the "AI Factory.”

And these AI factories are not being designed for human-speed operations, but rather for machine-speed operations.

This creates a generational opportunity for telecommunications service providers (SP). By building new (or transforming existing) data centers and edge locations into AI factories, SPs can offer hosted AI services that are high-performance, low-latency and compliant with regional requirements.

However, building an AI factory isn't just about racking GPUs. It is about realizing that an AI infrastructure presents a fundamentally new threat landscape that legacy security cannot handle. If the SP’s AI factory is compromised (if models are poisoned, identities hijacked, training data exfiltrated) the damage to reputation and national infrastructure is incalculable.

To capture the AI opportunity, service providers need more than computing power; they need a blueprint for a secure AI architecture. At Palo Alto Networks, we view the security of the AI factory as a three-tiered layer cake, requiring holistic, integrated protection from the physical infrastructure up to the AI agents themselves.

The AI Threat Model Is a Structural Shift

For service providers building AI Factories, the challenge is not simply adding another workload to the data center. AI changes the risk equation entirely. It introduces new traffic patterns, new identities and new forms of autonomy that traditional network and core security architectures were never designed to govern.

• Data Gravity Becomes Attack Surface: AI training and inference environments ingest massive volumes of data from distributed enterprise customers, partners and edge environments. This scale creates a new exposure layer. Malicious payloads, embedded model manipulation, and command-and-control traffic can hide within high-throughput AI data flows. Inspection models built for deterministic traffic patterns struggle when confronted with dynamic, AI-driven pipelines.
• Non-Human Identities at Scale: An AI Factory is more than just infrastructure; it will be populated by autonomous agents. These agents retrieve data, call APIs, invoke tools and trigger workflows across networks and cloud environments. They require elevated privileges to function. For service providers, this means managing not just subscriber identities, but fleets of machine identities operating with delegated authority.
• Agentic and Adversarial Threats: Attackers are also operationalizing AI. They probe for weaknesses faster, automate exploitation and increasingly target the AI systems themselves. Prompt injection can redirect an agent’s mission. Data poisoning can subtly degrade model integrity. Rogue agents can be manipulated to access external tools or escalate privileges. These are not traditional perimeter attacks; they are attacks on reasoning, behavior and autonomy.

For service providers offering AI-as-a-Service, the implication is clear: Securing the AI Factory requires more than network defense. It requires real-time governance of models, agents and data flows, ensuring that autonomous systems operate within defined policy boundaries while maintaining performance and scale.

The Foundation — Securing the High-Performance Infrastructure

The base of our cybersecurity stack is the physical and virtual infrastructure of the AI factory itself. This is a high-stakes environment. In a multitenant SP data center, you might have a financial institution fine-tuning a fraud detection model on one rack, and a government agency running inference on satellite imagery on the next. The barriers between these tenants must be absolute.

Foundational cybersecurity has two critical components: perimeter defense and internal segmentation.

The ML-Powered Perimeter

The front door of the AI factory must handle unprecedented throughput while performing deep inspection. Traditional firewalls, relying on static signatures, become bottlenecks and fail to catch novel threats hidden in massive data streams.

Palo Alto Networks addresses this with our flagship ML-Led Next-Generation Firewalls (NGFW). We have embedded machine learning directly into the core of the firewall. Instead of waiting for a patient zero to be identified and a signature created, our NGFWs analyze traffic patterns in real-time to identify and block unknown threats instantly. For an SP, this means you can provide the massive bandwidth required for AI data ingestion without compromising on security inspection at the edge.

Zero Trust Segmentation Inside the Factory

The perimeter is just the start. Once inside the data center, the biggest risk is the lateral movement threats and malware. If an attacker compromises a low-security tenant or a peripheral IoT device, they must not be able to jump to the sensitive GPU clusters or the model storage arrays.

In an AI factory, workloads are highly dynamic and virtualized. We provide robust segmentation across both hardware and software environments. We can enforce granular policies between virtual instances, containers and different stages of the AI pipeline (e.g., isolating training environments from inference operations). This allows a breach in one segment to be contained instantly, protecting the integrity of the entire factory.

The Engine – Securing AI Agents, Apps and Identities

The middle layer of the security stack is where the actual "work" of AI happens – the models, the LLMs, the agents. This is the newest frontier of cybersecurity and where traditional tools are most deficient.

This layer faces two distinct challenges: Protecting the integrity of the AI interaction and managing the identities of the nonhuman actors.

Securing AI Apps and Agents

As enterprises evolve from standalone LLMs to agentic AI systems that reason, call tools, access data, and take action across workflows, the challenge is no longer just what a model says; it is what an AI agent does.

How do you validate that an LLM powering your AI factory does not expose sensitive information, and that autonomous agents cannot be manipulated through jailbreak prompts, tool injection or malicious instructions? How do you prevent an AI agent from accessing unauthorized systems, escalating privileges, or executing unintended actions?

This is the role of Prisma^® AIRS – our security and governance platform for AI agents, apps, models and data. Prisma AIRS operates directly in the execution path of AI applications and autonomous agents. It enforces policy in real time, validates agent behavior, and blocks prompt injection, model manipulation and agent hijacking before they can impact the business.

Beyond filtering outputs, Prisma AIRS governs agent communications, tool access and data flows to prevent credential leakage, mission drift and unauthorized actions. For service providers delivering AI-as-a-Service, or enterprises deploying AI agents internally, Prisma AIRS enables integrity, compliance and continuous control as intelligent systems move from experimentation into mission-critical operations.

Built in alignment with emerging standards like the OWASP Agentic Top 10 Survival Guide, Prisma AIRS operationalizes best practices to defend against real-world agentic threats.

Governing Nonhuman Identity

Perhaps the most profound shift in the AI factory is who or what is doing the work. We are rapidly moving toward ecosystems of autonomous AI Agents. These agents need to authenticate to databases, authorize API calls to other services, and access privileged information just like a human employee.

If an attacker steals the credentials of a high-privilege AI agent, they own the factory.

This is why the Palo Alto Networks acquisition of CyberArk, the global leader in Identity Security, is so strategic for the AI era. CyberArk specializes in protecting privileged access, and crucially managing nonhuman identities. By integrating CyberArk’s capabilities, we can ensure that every AI agent operating within the SP’s factory is robustly authenticated, authorized for minimum necessary access, and its activities are monitored. We are securing the new digital workforce.

The Overwatch – Holistic, AI-Driven Threat Management

The top layer of the stack is about visibility and speed. An AI factory generates a deafening amount of telemetry data from networks, endpoints, clouds and identity systems. No human security operations center (SOC) can sift through this noise manually to find a sophisticated attack.

To fight AI-driven threats, you need AI-driven defense.

This is the role of Cortex^®, our flagship platform for holistic threat management. Cortex is designed to ingest billions of data points from across the entire Palo Alto Networks product portfolio and hundreds of types of third-party equipment, normalizing it into a single source of truth.

Cortex applies advanced AI and machine learning to this vast data lake to detect anomalies that signal a complex attack spanning different threat vectors. It might correlate an unusual login event from an AI agent (detected by the identity layer) with a subtle change in outbound traffic patterns at the firewall (layer 1), recognizing it as data exfiltration in progress.

For a Service Provider, Cortex provides the "single pane of glass" view over their entire AI factory operations, allowing them to detect, investigate and automatically respond to threats at machine speed, vastly reducing Mean Time to Respond (MTTR).

Building the Trust Foundation for the Agentic Era

The transition to becoming an AI factory is a necessary evolution for Service Providers seeking growth in the coming decade. Your ability to offer localized, sovereign, high-performance AI services will differentiate you from those who large-scale and cement your role as an indispensable partner to enterprises and governments.

But this opportunity is inextricably linked to trust. Your customers will not move their most sensitive data and IP into your AI factory unless they are certain it is secure against modern threats.

Security cannot be an afterthought bolted onto an AI infrastructure. It must be woven into the fabric of the factory, from the silicon to the software agents. By adopting a layered approach (securing the high-performance infrastructure with ML-led NGFWs, protecting models and identities with Prisma AIRS and CyberArk, while managing the entire landscape with Cortex) Service Providers can build the trusted foundations the AI era demands.

This week we’ll be at Mobile World Congress talking about our security platform for AI Factories, along with five solutions and ecosystem partners. Come see us at in Hall 4, Stand #4D55.

The post Why Service Providers Must Become Secure AI Factories appeared first on Palo Alto Networks Blog.

Artificial intelligence has shifted to being the primary engine for market leadership. To compete, enterprises are shifting from general-purpose computing to AI factories, specialized infrastructures designed to manage the entire lifecycle of AI. However, this transition requires robust security without sacrificing performance and efficiency.

We are proud to announce that Palo Alto Networks Prisma^® AIRS™, accelerated on the NVIDIA BlueField data processing unit (DPU), is now part of the NVIDIA Enterprise AI Factory validated design.

The integrated solution embeds zero trust security directly into the AI infrastructure, providing comprehensive protection without impacting AI performance. By deploying Palo Alto Networks Prisma^® AIRS™ Network Intercept directly onto the NVIDIA BlueField and extending to the cloud, Prisma AIRS establishes an essential zero trust governance fabric for the AI factory, enabling enterprises to accelerate innovation while maintaining control.

This critical architectural shift enables optimal AI performance and infrastructure efficiency by offloading security processing to an isolated domain, while leveraging the DPU's hardware acceleration via NVIDIA DOCA to enforce security policies at line speed. The implementation also leverages real-time workload information captured using DOCA Argus, which is then passed to Cortex XSIAM^® where it is used for AI-driven responses using the Cortex XSOAR^® orchestration platform.

Rich Campagna, SVP Product Management, Palo Alto Networks said:

The AI Factory is the new engine for value creation, and securing it is a board-level imperative. The validation of Palo Alto Networks Prisma AIRS accelerated with NVIDIA BlueField within the NVIDIA Enterprise AI Factory enables a new security architecture for the AI era. We are embedding trust directly into the infrastructure, giving leaders the confidence to safeguard their proprietary intelligence and deploy AI bravely.

Kevin Deierling, senior vice president of Networking at NVIDIA said:

AI is transforming every industry and security must evolve to protect AI factories. To be scalable, security must be distributed and embedded within the AI infrastructure. This is achieved with NVIDIA BlueField running Palo Alto Networks Prisma AIRS to deliver robust, runtime security for the AI factory, with optimal AI performance and efficiency.

Deploy AI Bravely with a Future-Proof Foundation

The Future of Secure AI Factories

In addition to deploying Palo Alto Networks Prisma AIRS on NVIDIA BlueField in a distributed model, it’s essential to maintain a centralized Hyperscale Security Firewall (HSF) cluster at the ingress and egress points of the AI factory to enforce a defense-in-depth strategy. Beyond network segmentation, individual workloads can selectively route traffic through hyperscale clusters to detect advanced application-layer threats and prevent lateral movement. These hyperscale firewall clusters scale elastically with demand, delivering session resiliency and the high availability required for critical AI operations.

This architecture fundamentally improves the Total Cost of Ownership (TCO) for AI infrastructure. By isolating security functions on BlueField, enterprises enable 100% of host computing resources to be dedicated to AI applications. This elimination of resource contention allows the AI Factory to maximize token throughput and capital efficiency.

This validated design is the blueprint for immediate efficiency. It provides a seamless path for enterprises to shift from general-purpose clusters to secure AI factory infrastructure without costly overhauls. More importantly, this collaboration establishes an unparalleled roadmap for future-proofing your investment. By securing operations with the high-performance NVIDIA BlueField-3 today, the architecture is inherently ready for the next generation, NVIDIA BlueField-4. This forward compatibility helps AI factories immediately handle gigascale demands, scaling up to 6X the compute power and doubling the bandwidth when BlueField-4 becomes available.

The inclusion of the Palo Alto Networks Prisma AIRS platform in the NVIDIA Enterprise AI Factory Validated Design bolsters enterprise AI security. By establishing the zero trust governance fabric of Prisma AIRS runtime security on NVIDIA BlueField, organizations gain a comprehensive defense. Proprietary and sensitive data is secured throughout the entire stack, and models are protected from adversarial threats, such as prompt injection attacks. With Prisma AIRS, the world's most comprehensive AI security platform, leaders gain the confidence to innovate and deploy AI bravely. This validated design is the essential blueprint for securely accelerating your market leadership without compromising security.

Join our "How to Secure the AI Factory" breakout session at NVIDIA GTC 2026, March 16-19, in San Jose, CA to hear more about this transformative solution and accelerate your AI innovation securely.

The post Palo Alto Networks Announces Support for NVIDIA Enterprise AI Factory appeared first on Palo Alto Networks Blog.

The transformative potential of artificial intelligence (AI) across industries is undeniable. But realizing AI's true value hinges on three cybersecurity imperatives: Understanding the AI-cybersecurity nexus, harnessing AI to supercharge cyber defense, and embedding security into AI tools from the ground up through Secure AI by Design.

Nowhere is this convergence more urgent than in financial services. Sitting at the center of our global economy, financial institutions face a dual mandate: Embrace AI for cybersecurity and cybersecurity for AI.

I was honored to cover these key principals in my testimony before the House Committee on Financial Services, led by Chairman French Hill. The hearing, entitled “From Principles to Policy: Enabling 21st Century AI Innovation in Financial Services” convened witnesses from Palo Alto Networks, Google, NASDAQ, Zillow and Public Citizen. Together, we examined AI use cases in the financial services and housing sectors, including those specific to cybersecurity. We assessed how existing laws and frameworks apply in the age of AI.

The Defense Advantage Is AI-Powered Security Operations

Attacks have become faster, with the time from compromise to data exfiltration now 100 times faster than four years ago. The financial sector bears disproportionate risk, given the value of its data and interconnected systems, while firms contend with evolving regulatory expectations, talent shortages and the persistent tendency to elevate cybersecurity only after an incident.

Generative and agentic AI intensify these pressures by accelerating every phase of the attack chain, from deepfake-driven fraud to tailored spear phishing campaigns. Our researchers at Unit 42^® have found that agentic AI, autonomous systems that can reason and act without human intervention, can compress what was once a multiday ransomware campaign into roughly 25 minutes.

To keep pace, financial institutions must pivot to AI-driven defenses that operate at machine speed.

Security operations centers (SOC) have long been overwhelmed by traditional alerts and fragmented data. Security teams, forced into manual triage across dozens of disparate tools, face an inefficient model that leaves vulnerabilities exposed, burns out analysts and makes it impossible to operate at the speed necessary to outpace modern attacks.

The average enterprise SOC ingests data from 83 security solutions across 29 vendors. In 75% of breaches, logging existed that should have flagged anomalous behavior, but critical signals were buried. With 90% of SOCs still relying on manual processes, adversaries have the clear advantage.

AI-driven SOCs flip this paradigm, acting as a force multiplier to substantially reduce detection and response times. To illustrate the scale of this necessity, consider our own security operations. Palo Alto Networks SOC analyzes over 90 billion events daily. Without AI, this would be an impossible task for human analysts. But by applying AI, we distill that down to a single actionable incident.

Financial institutions migrating to AI-driven SOC platforms are seeing transformative results:

• One customer reduced the Mean Time to Respond (MTTR) from one day to 14 minutes.
• Another prevented 22,831 threats and processed 113,271 threat indicators in less than 5 seconds.
• A large bank saved 180 hours per year by automating security information and event management reporting; 500 hours through automated data collection; 360 hours by automating four Chief Technology Officer playbooks; and 240 hours with automated threat intelligence enrichment.

These improvements are critical to stopping threat actors. But none of this would be possible without AI.

Securing the New AI Attack Surface

As AI adoption grows, it will further expand the attack surface, creating new vectors targeting training data and model environments. AI's rapid growth is outpacing the adoption of security measures designed to protect it. Nearly three-quarters of S&P 500 companies now flag AI as a material risk in their public disclosures, up from just 12% in 2023.

Traditional security tools rely on static rules that miss advanced attacks, like multistep prompt injections or adversarial manipulations. Autonomous AI agents can take unpredictable actions that are difficult to monitor with legacy methods.

Rapid AI adoption has exposed organizations' infrastructure, data, models, applications and agents to unique threats. Unlike traditional cyber exploits that target software vulnerabilities, AI-specific attacks can manipulate the foundation of how an AI system learns and operates.

A Secure AI by Design

Even with an understanding of the risks, many organizations struggle with the lack of clarity on what effective AI security looks like in practice. Recognizing the gap between intent and execution, Palo Alto Networks developed a Secure AI by Design policy roadmap that provides organizations with a comprehensive roadmap that integrates security throughout the entire AI lifecycle.

A proactive stance ensures security is a feature, not an afterthought, crucial for building trust, maintaining compliance and mitigating risks. The approach addresses four imperatives organizations most pressingly face in AI adoption:

1. Secure the use of external AI tools.

2. Secure the underlying AI infrastructure and data.

3. Safely build and deploy AI applications.

4. Monitor and control AI agents.

The Path Forward

For financial institutions, Secure AI by Design must be anchored in enterprise governance. Institutions should maintain risk-tiered AI inventories, enforce strict access controls and implement testing commensurate with risk. Governance structures should enable board oversight and align with established model risk practices.

Policymakers also have a critical role to play in promoting AI-driven security operations, championing voluntary Secure AI by Design frameworks, ensuring policies safeguard innovation, enabling controlled experimentation and strengthening public-private collaboration.

Ultimately, the financial institutions that will thrive will recognize cybersecurity as the foundation that makes innovation possible. By embracing AI-driven defenses and securing AI systems from the ground up, the sector can confidently unlock AI's transformative potential while safeguarding the trust and stability that underpin the global economy.

Read the full testimony to learn more about how cybersecurity can enable AI innovation in financial services.

The post From the Hill: The AI-Cybersecurity Imperative in Financial Services appeared first on Palo Alto Networks Blog.

This webcast was originally aired on January 16, 2025. In this video, Kelli K. Tarala and CJ Cox discuss the challenges and strategies for improving governance, risk, and compliance (GRC) […]

The post GRC for Security Managers: From Checklists to Influence appeared first on Black Hills Information Security, Inc..

Risk is real. To better understand cybersecurity risk, let’s compare cyber risks to risks in the natural world from hurricanes. We can learn lessons from hurricanes and unnamed storms in […]

The post Cyber Risk Lessons We Can Learn From Hurricane Preparedness appeared first on Black Hills Information Security, Inc..