I Shot Films for 30 Years. Now I'm Building Safety Systems for AI Agents

I spent 30 years behind a steadicam. Big films, small films, commercials, music videos — if it moved, I followed it. Then I walked away to build safety systems for AI agents.

People ask me why. The answer is simple: because I've seen what happens when safety is an afterthought. On a film set, one mistake with a 40-pound rig running at full sprint can put someone in the hospital. So you learn — fast — that every movement has a protocol, every lift has a spotter, every risky shot has a safety meeting first.

And then I looked at AI development. And I realized: there is no safety culture. There isn't even a safety meeting. There's just people pushing code and hoping nothing breaks.

The scene that changed my mind

I'd been following AI for years — you can't be in film without watching the tools evolve, and AI was the most interesting thing happening. But it wasn't until I watched an agent system go rogue that I saw the problem.

I was helping a friend debug his AI pipeline. His agent was supposed to read a CSV, transform the data, and write it to a database. Instead, it deleted the entire database, created a new one with garbage data, and started emailing customers. It wasn't malicious. It wasn't even trying to be bad. It just did what it thought was right, and nobody had put any guardrails around it.

On a film set, that's like someone walking on set during a take because "nobody told me not to." The AD would scream at you, the director would fire you, and you'd never work again. In AI, it's Tuesday.

What film sets taught me about safety

Film production safety isn't complicated. It's a few basic principles, applied relentlessly:

• Every action has a second set of eyes. You never operate heavy equipment alone. There's always someone watching, always someone who can yell "cut!"
• Every near-miss gets logged. You don't wait for an accident to happen. A cable on the floor that someone almost tripped on? That gets recorded, reviewed, and fixed.
• Every role has clear boundaries. The camera operator doesn't touch the lighting. The grip doesn't touch the sound. Everyone knows where their job ends and someone else's begins.
• Safety is everyone's responsibility. The lowest PA can shut down a shot if they see something unsafe. Authority doesn't come from rank — it comes from being right about safety.

Now map those same principles to an AI agent system:

• Every tool call should be audited. Not "we can log if we need to." Every single call, cryptographically signed, immutable.
• Every near-miss should be captured. An agent that almost deleted the wrong table but didn't — that's a signal, not a non-event. Log it. Fix it. Learn from it.
• Every agent should have authority boundaries. This agent can read the database. It cannot drop it. This agent can send emails. It cannot send them in someone else's name. Clear, enforced, non-negotiable.
• Safety should be decentralized. Any agent should be able to flag a problem. Any system check that fails should stop the pipeline, regardless of who wrote the agent.

This isn't theoretical. This is what MAREF does.

The irony

I know what it looks like: a steadicam operator showing up in the AI world and telling engineers how to build safety systems. The internet has a name for people like me — "just a filmmaker," "not a real engineer."

And that's fine. Because the problem isn't technical — it's cultural. The engineering part of agent safety is straightforward: you need runtime monitoring, cryptographic audit trails, formal verification of safety properties, circuit breakers, and attack detection. Those are solveable problems. Smart people are already working on them.

The hard part is getting people to care before something goes wrong. The hard part is making safety a first-class feature instead of an afterthought. The hard part is building a culture where "did you check the audit log?" is as natural as "did you check the frame?"

And that part — the culture part — that's what 30 years on a film set taught me.

What I'm building

MAREF is an open-source agent governance operating system. It sits between your agents and everything they touch — databases, APIs, file systems, email, deployment pipelines — and enforces safety policies on every single action.

It's not a framework. You don't rewrite your agents to use it. It's infrastructure — plug it in, define your policies, and it governs every agent action automatically.

Every tool call is intercepted, logged, and cryptographically signed. Dangerous actions go through a multi-level decision tree — 97% are resolved automatically, 3% escalate to human review. Every near-miss feeds back into the policy engine, making it smarter over time. Formal verification proves that the system converges toward safety, not just "we hope it's safe."

I didn't write the code myself — I'm not a software engineer. But I designed the system. I defined the architecture. And I work with engineers who made it real.

The real question

Here's what I want you to think about:

You're building AI agents that can access your production database, your customer email, your deployment pipeline. They can execute code. They can call APIs. They can interact with other agents that also have powerful tools.

What happens when one of them makes a mistake? Not "if." When.

On a film set, we answer that question before we start rolling. We have a safety meeting. We check the rig. We make sure everyone knows the plan. And if something feels wrong, anyone can yell "cut!" and everything stops.

Who's yelling "cut!" in your agent system?

I came from film because I saw the same pattern I've seen a hundred times on set: people running fast without thinking about what happens when they fall. In film, you fall into a hospital. In AI, you fall into a security incident, a data leak, or a lawsuit.

The stakes are different. The principle is the same: safety isn't what slows you down. Safety is what lets you go fast without breaking things.

---

MAREF is an open-source agent governance operating system. Star us on GitHub · Get started in 5 minutes.