Your Firewall Is Working. But Is Your System Actually Secure?

The Firewall Is Doing Its Job

A firewall has a simple responsibility: control what enters and leaves a network based on defined rules.

For years, this was one of the foundations of cybersecurity. If traffic came from an untrusted source, block it. If it matched an approved rule, allow it.

And firewalls are still important. But modern systems no longer live behind one clearly defined network boundary.

Employees work remotely. Applications run in the cloud. Devices connect from different locations. Companies use APIs, SaaS platforms, mobile devices, contractors and multiple cloud environments.

So, the security question is changing.

Instead of asking:

we increasingly need to ask:

“Who is requesting access, what are they trying to access, and should they be allowed to do it?”

That is where Zero Trust (opens in a new tab) comes in.

What If There Is No Trusted Perimeter?

Traditional security was heavily influenced by a simple assumption:

But imagine an employee connecting from home.

Now imagine an attacker has stolen that employee's credentials and connects using the same account.

The request may look legitimate. Should the system automatically trust it? Zero Trust takes a different approach.

It assumes that no user, device, application or connection should receive implicit trust simply because of its network location.

Every access request should be evaluated using information such as identity, device security, context and risk.

The goal is not to block everything.

The goal is to give the right access to the right resource at the right time.

From "Can You Enter?" to "What Are You Allowed to Do?"

This is one of the biggest changes in modern cybersecurity.

A traditional perimeter asks:

Zero Trust asks:

National Institute of Standards and Technology's (NIST (opens in a new tab)) Zero Trust Architecture (opens in a new tab) uses policy decision and enforcement components to make and enforce these access decisions.

A simplified view looks like this:

Access is no longer a permanent assumption. It becomes a decision.

And Now We Have AI Agents

This becomes even more important when we introduce AI agents.

An AI agent isn't simply a person logging into an application.

Depending on its configuration, an agent may be able to access documents, query databases, call APIs, use tools or trigger workflows.

So, the security question changes again.

It is no longer enough to ask:

We need to ask:

For example:

The network connection might be completely legitimate.

The action could still be inappropriate.

Security Doesn't End When Access Is Granted

This is where governance becomes important.

Imagine an AI agent has permission to use a particular API.

Does that mean every action it performs through that API should automatically be allowed?

Not necessarily.

A stronger security model can evaluate the requested action before execution:

This is particularly important for AI systems because they can move from generating information to actually performing actions.

Where Does ART Fit into This?

This is also where the ideas behind Zero Trust connect naturally with modern AI-agent platforms (opens in a new tab).

A Realtime Tech (ART) (opens in a new tab) brings AI agents, workflows, business systems and real-time events together while providing mechanisms such as scoped access, governance, human approval and execution traceability.

The principle is simple:

“An AI system should not only be capable of taking an action. Its access and actions should also be controllable and observable.”

A simplified workflow could look like:

This doesn't replace Zero Trust. It demonstrates how Zero Trust principles can extend into systems where software itself can make decisions and perform actions.

You can learn more about ART's approach to governed AI-agent workflows here: A Realtime Tech (opens in a new tab)

Zero Trust Doesn't Replace the Firewall

Zero Trust is not:

It is closer to:

The firewall still protects the network layer.

Identity determines who or what is requesting access.

Least privilege ensures that users, devices and applications receive only the minimum access they need to perform their task - nothing more.

Access controls determine what they can access.

Policy determines what should be allowed.

Monitoring helps determine what is actually happening.

And security teams can respond when something goes wrong.

The result is a layered security model rather than dependence on one perimeter.

But "Trust Nothing" Is Easier Said Than Done

Zero Trust sounds simple:

Implementing it is much harder.

Organizations need reliable identity systems, asset visibility, access controls, logging, monitoring and well-defined policies.

And these security mechanisms can fail too.

NIST identifies challenges including stolen credentials, insider threats, compromised policy components, denial-of-service attacks, limited visibility and false positives or false negatives.

This creates an important question:

“What happens when the system responsible for enforcing security becomes unavailable or compromised?”

The security system itself becomes part of the attack surface.

The Bigger Picture

The evolution of cybersecurity is not:

It is more like:

And with AI agents, we need to ask even more questions:

“Who can access the system?”

“What can the system access?”

“What can the agent do?”

“Which actions require approval?”

“Can we see what happened?”

“Can we stop or recover when something goes wrong?”

The firewall is still there.

But the definition of "secure" has become much bigger.

Conclusion

A firewall can protect a boundary, but modern systems don't have one boundary anymore. Users, devices, applications, cloud services, APIs and AI agents can all interact with organizational resources from different locations and contexts. Zero Trust responds by replacing implicit trust with explicit access decisions based on identity, context and least privilege. As AI systems become capable of taking real actions, these principles also need to extend to the agents, tools and workflows they control.