The Missing Law of Motion

Why Digital Will Requires Digital Gravity

Originally published on Medium, November 27, 2025.

“Freedom is the recognition of necessity.” — Baruch Spinoza

It’s 8:42 PM on a Sunday.

Over 120,000 devices hit a stadium network as kick-off time approaches. Point-of-sale devices lag. The video feeds spike. The biometric scanners show ‘offline’ intermittently. The network — engineered for exactly this moment — is humming at 94% capacity. It is a marvel of modern infrastructure, but it is stretched to the absolute limit of its physics.

In a data center three states away, an AI Agent wakes up. It has one job to do: Deploy a critical microservice update to the ticketing gateway.

• Identity: Verified.
• Permissions: Valid.
• Deployment Window: Open.
• Environmental Awareness: None.

The Agent cannot see the 120,000 devices. It cannot feel the 94% capacity. It has no concept of ‘stadium’ or ‘kick-off’ or ‘Sunday night.’

By every measure of policy and protocol, the Agent is allowed to act. The dashboard is green. The change is approved. But the Agent doesn’t know the stadium is full. It doesn’t feel the latency creeping up on the edge switches. It cannot sense what will break if wifi goes down.

It only knows: “You have permission.”

So it acts.

• T+0.01s: The update initiates.
• T+0.05s: The load balancers, already redlining, mistime a handshake.
• T+0.15s: The retry storm begins.
• T+2.00s: The stadium network buckles.
• T+2.30s: 50,000 phones lose signal simultaneously.
• T+3.00s: Point-of-sale terminals freeze mid-transaction.
• T+5.00s: The first angry fan reaches the help desk.

The Agent has no idea any of this is happening. Its logs show: Deployment: Successful.

This failure hasn’t made headlines yet. But it will.

Variations are already playing out in hospitals during patient surges, in financial markets during volatility spikes, in cloud platforms during traffic storms.

The only difference is scale.

We’re deploying agents faster than we’re building the physics to constrain them.

The math is simple: more agents + less awareness = inevitable collapse.

We will have agents with godlike capabilities but toddler-level awareness. They will have Digital Will (the power to act), but the environment will have no Digital Gravity (the power to resist).

They will have power without proprioception (i.e., the ability to sense their own position in space). They will stumble. They will fall. And when they fall, they will take us with them.

The Asimov Trap

For fifty years, we have been fighting the wrong battle.

We looked at the potential of AI and asked: “How do we align its intent?

How do we make it ‘Good’?”

We obsess over Isaac Asimov’s “Three Laws of Robotics.”

We debate the ethics of the machine.

We spend billions on alignment, trying to solve the “Paperclip Maximizer” problem.

But Asimov made a big assumption. He assumes the environment is stable.

It is not.

Asimov’s laws tell the robot: ‘Don’t run if you will hit a human.’ They don’t tell the robot: ‘Don’t run if the floor is made of ice.’ And they surely don’t give the ice the power to veto the run.

The laws assume the robot is the only actor. But in the physical world, there are always two actors: the agent and the environment. Asimov gave us laws for the agent. We need laws for the environment.

In the physical world, if a sprinter tries to run on ice, they don’t need a policy to tell them to stop. Friction — or the lack thereof — vetoes their motion physically.

The environment imposes a hard limit on their will.

In the digital world, we have created a vacuum. We paved the roads with infinite, frictionless asphalt called “Static Permissions.” We told the Agent it was allowed to drive 1000mph, but we didn’t give it eyes to see the cliff.

The Static Fallacy

The core failure is not the Agent. The failure is that our implementation of Zero Trust cannot keep pace with machine-speed.

We have spent a decade implementing Zero Trust. The premise was sound: “Never trust, always verify.” But we implemented it with human-speed verification cycles in a world where agents act at machine-speed.

Here’s the problem: If I verify an Agent’s identity at 10:00:00 AM, and the network is compromised at 10:00:01 AM, that Agent still holds the keys. The verification was correct at the moment it was issued. But in the millisecond gap between “verified” and “acted,” the ground shifted.

Tennessee Williams wrote:

“Time is the longest distance between two places.”

In cybersecurity, he was prophetic. The distance between T+0.01s (update initiates) and T+2.00s (network buckles) is only 1.99 seconds — but it is an unbridgeable chasm. In that tiny amount of time, a legitimate deployment agent could push a configuration change that cascades across 50 microservices — each one trusting the credential, none of them aware that the originating node is now hostile, now an active threat.

By the time a human analyst sees the alert, the damage is done and the cascade begins.

The Agent was verified at T+0.00s. The environment was compromised at T+0.01s. The distance between those two moments — one hundredth of a second — is the longest distance in the world.

This isn’t just a technology problem. It’s a systemic one.

The entire lifecycle of identity artifacts — API tokens, service accounts, secrets, session cookies — is built for human timescales:

• People: Security teams manually review access requests. Approvals take hours.
• Process: Provisioning workflows require tickets and change windows.
• Governance: Policies are written in static documents, reviewed quarterly.
• Data: Identity stores are updated in batch cycles, not real-time.
• Technology: Secrets rotation happens on 30-day cycles, not in response to environmental changes.

When we have hundreds of thousands of autonomous agents executing decisions in parallel, this lifecycle becomes the bottleneck. We cannot rely on static policies checked at deployment time. We need permissions that update as fast as the environment changes.

In our current model, identity is a Passport — valid until it expires. In a kinetic model, identity must be a Vector — constantly validated against the shifting physics of the environment.

You cannot govern kinetic threats with static policies.

The Missing Law

We are not going to firewall our way out of this. We are not going to audit our way to safety.

We need something more fundamental. We need the missing law of motion.

Ada Lovelace saw in 1843 that machines could manipulate symbols, not just calculate numbers. We need to go further: machines that can sense the physics of their environment, not just execute instructions.

An AI doesn’t just need to know what to do; it needs to know whether the environment can support that action.

We need to go deeper than Asimov. We need a law that comes before intent, before morality, before the question of “good” or “evil.” We need a law that governs possibility itself.

If we were to draft this new foundation — call it the Zeroth-Zeroth Law, the law of physical constraint — it would be this:

An Agent’s autonomy must never exceed the environment’s stability.

A ≤ E

This is not a guideline. It is not a best practice. It is not a policy that can be waived during an emergency.

It is a law of nature — for the digital world.

This is not a moral constraint. It is a physical one.

It doesn’t ask whether the Agent should act. It asks whether the environment can support the action.

In the physical world, you don’t get a vote on whether you can run on ice. The ice decides. Friction is the final authority.

What if, before that Agent deployed the update, it had to feel the weight of the stadium? What if the atmospheric pressure of the network physically compressed the Agent’s permissions, shrinking its autonomy as the risk increased?

What if the environment didn’t just advise — it enforced? The Agent would still have its credential. The deployment window would still be open. But the environment would say: ‘Not now. Not here. Not safe.’

And the Agent would have no choice but to wait.

This is the shift.

We stop treating authorization as a binary gate (“allowed” or “blocked”) and start treating it as a physical force, one that expands in calm conditions and contracts under stress.

Spinoza wrote that freedom is the recognition of necessity. An Agent is not free because it can do anything. It is free because it acts within the bounds of what is possible — constrained by the necessity of the environment.

The Collapse of TTGD

In traditional security, Time-to-Good-Decision (TTGD) — the time it takes to detect, decide, and act on a threat — is measured in minutes or hours. The median is 11 hours. Against an AI Agent moving at machine speed, that’s not just slow. It’s catastrophic.

An autonomous agent can execute 1,000 API calls per second. In 5 minutes, that’s 300,000 actions. In 11 hours, that’s 39.6 million. If even 0.1% of those actions are destructive, that’s 39,600 compromised systems. If remediation costs average in the thousands per system, the damage reaches hundreds of millions — before the first human even sees the alert. By the time a human analyst sees the alert, investigates, and decides to cut access, the damage isn’t just done — it’s compounded exponentially.

When we replace Policy with Physics, TTGD collapses from hours to milliseconds.

The environment doesn’t need to “decide” to stop the Agent.

It doesn’t convene a committee or wait for approval. The moment the Trust Score drops below the threshold for the requested action, the Silent Veto triggers.

The Trust Leash snaps tight.

The credential is rejected — not in 11 hours, not in 5 minutes, but in the time it takes to validate a cryptographic token.

The system protects itself faster than any human could react.

This is not faster incident response. This is pre-incident prevention. The cascade never starts because the environment vetoed the first step.

The Trust and Access Office (TAO)

This requires a new architectural concept — one I’ve written about in detail: the Trust and Access Office (TAO).

TAO is not a ticket queue. It is not a room full of people rubber-stamping requests. It is the Governance Layer of Digital Physics — the office responsible for defining the immutable laws of your universe.

• They don’t write policies. They set the physics.
• They define the coefficients of friction.
• They determine the weight of risk.
• They sign the constants with the organization’s root keys, and those constants become the gravitational field that every agent must navigate.

This is the shift from legislating behavior to engineering reality.

It solves the Autonomy-Safety Tradeoff. We no longer have to choose between “Move Fast” and “Be Safe.”

We no longer have to pick between innovation and survival.

• Stable Environment? Long Leash. Maximum Velocity.
• Unstable Environment? Short Leash. Maximum Constraint.

We get speed when it is safe, and constraint when it is not. The environment decides, not a committee.

From Policy to Physics

This is the shift.

We are moving toward a future where authorization is not binary. It is kinetic.

This solves the Invisible Success Problem. Currently, AI safety is invisible — you can’t measure the disaster that didn’t happen. But in a physics-based world, we can measure the Trust Score (E) and its velocity. We can prove, mathematically, that an Agent was throttled because the environment was degrading.

We turn luck into metrics. We make the invisible, visible.

When the stadium network hit 94% capacity at T+0.00s, the Trust Score dropped from 87 to 62 in 0.01 seconds.

The Agent’s deployment was vetoed — not by a human, but by the math.

The log shows: ‘Deployment denied: Environment unstable.’

That’s not luck. That’s physics. And it’s auditable.

In Part II, we’ll explore how this law is enforced — not by humans writing policies, but by the environment itself. We’ll talk about the Silent Veto, the Trust Proof, and how a network learns to feel pain before it breaks.

But we don’t have decades to figure this out. The window is closing faster than we think.

We are deploying autonomous agents faster than we are building the physics to constrain them. Every day, we add more Digital Will to a universe with no Digital Gravity. Every day, the gap widens.

We have spent decades trying to make AI safe by controlling its intent. It is time to make AI safe by constraining its environment.

Because in the end, the question is not ‘What does the AI want?’

The question is: ‘What will the environment allow?’

And right now, the answer is: Everything. That’s the problem we solve next.

Continue to part II: https://medium.com/@chrisperkins505/the-ghost-in-the-machine-76f4b43f07ff