NullRun
AI Agent Governance
When I started building NullRun, I thought the main problem was controlling what an AI agent can do. After working on it for months, I think the harder problem is who actually has the authority to decide whether an action runs.
An agent can decide:
“I should refund this customer.”
But should the agent itself be the final authority to execute the refund?
Or:
“I should delete this database record.”
“I should deploy this change.”
“I should call this external API.”
The agent can request the action. The application can expose the tool.
But neither should automatically mean the action is authorized.
That's the gap I'm trying to solve with NullRun.
The agent sends an execution request to NullRun, and an external policy layer makes the runtime decision:
allow -> execute
require approval -> wait for a human decision
block -> don't execute
The important part is that the policy isn't just sitting in documentation or in a dashboard.
It is enforced at the point where the action is about to happen.
This also changes how I think about “AI governance”.
A lot of governance work is about policies, monitoring, logs, evaluations, and compliance evidence.
Those are useful.
But eventually you still need an answer to a very simple runtime question:
“Should this specific action execute right now?”
That's what I'm building toward with NullRun: an enforcement layer between AI agents and production systems.
I'm curious how other teams handle this today.
If your agent can call production tools, where does the final execution authority actually live?
Inside the agent?
Inside application code?
In middleware?
Or somewhere else?
Hey Indie Hackers
For the past 7 months I've been building NullRun - a runtime authorization layer that sits between your AI agents and the outside world.
The problem I'm solving:
Companies are shipping AI agents everywhere (LangChain, CrewAI, MCP-based), but most have zero control over what those agents actually do at runtime: an agent can blow through budget, trigger an unsafe tool call, or delete something in production - and nobody finds out until it's too late.
What NullRun does:
1 - statefull caps spend at the agent level
2 - blocks unsafe tool calls before they execute
3 - requires human approval for critical actions
4- logs and audits every decision the agent makes
It's a drop-in layer in front of any agent framework (LangGraph, CrewAI, OpenAI/Anthropic/Gemini agents) - no need to rewrite agent logic.
Status:
The product is production-ready, but revenue is still $0
I'm looking for my first pilot customers to validate whether teams already running agents in production are ready to pay for this kind of governance layer now, or if the market just isn't there yet.
Question for you:
If you're deploying AI agents to production right now - how are you handling budget control and unsafe actions? Duct-tape scripts, custom middleware, or nothing at all?
Would really appreciate any feedback, especially from anyone who's already gotten burned on agent spend or safety.
-
1
The $0 revenue is less interesting than the urgency question. Have you found teams already running agents that consider spend limits or unsafe tool calls painful enough to pay for now, or are most treating governance as a future problem?
Comment