Who Governs The Agents?

This question sits at the heart of the AGNTCY initiative, a new collective of organizations (including Orium— we joined as a founding member) working to define what a world of interoperable, trustworthy AI agents looks like.

As someone who spends my days embedded in security, risk management, and compliance, both for our client implementations and our own internal posture, this moment feels particularly urgent. The shift to an “Internet of Agents” amplifies both the opportunity and the threat surface at the same time.

Traditional software governance has always been about control: patch the vulnerability, restrict the permission, validate the configuration, block the suspicious request, etc.

But agents break this pattern. They’re not static code; they’re dynamic systems with:

• emergent behaviours
• evolving capabilities
• multiple decision layers
• opaque reasoning boundaries
• growing degrees of autonomy

In other words: we’re now governing systems that can rewrite their own approach to problems faster than traditional governance frameworks can keep up.

The rate of change is no longer linear. It’s exponential and accelerating. Which means it’s easy to be overwhelmed.

This is the tension every security or compliance leader now feels: how do we maintain guardrails without handcuffing innovation? How do we honour customer trust while still moving at a pace that matches the technology’s trajectory?

This is where the open-source imperative becomes essential.

The closest analogue we have for a healthy, scalable governance model is the Linux Foundation. It doesn’t just provide code; it provides trust, stewardship, and a neutral place where competitors can collaborate on the infrastructure of the modern internet.

AI agents require something similar, perhaps even more robust. Here’s why:

1. No single company can (or should) control the agent ecosystem. Agents will communicate, interoperate, and orchestrate across platforms, meaning governance must be pluralistic. Proprietary guardrails can’t meaningfully scale across an ecosystem defined by autonomy.

2. Open standards prevent fragmentation. We’ve already seen what happens when AI technologies evolve faster than their governance: inconsistent safety baselines, incompatible agent formats, and unpredictable behaviours across tools. Open infrastructure creates shared expectations, shared protocols, and shared accountability.

3. Transparency builds trust, the currency of the agent era. When agents act on behalf of humans and organizations, trust isn’t optional; it’s existential. Open-source communities allow for independent audits, external scrutiny, and collective problem-solving— things closed systems inherently resist.

4. Open governance accelerates innovation without sacrificing safety. Paradoxically, structure creates speed. A well-defined, community-governed baseline means everyone can innovate on top of the foundation, instead of reinventing it from scratch.

I spend most of my time sitting at the intersection of “move fast” and “don’t break anything important” in my role as Senior Director of Standards, Compliance & IT Services.

One thing I know for sure is that we can’t treat agent governance like traditional change management. By the time a quarterly review arrives, an agent-based system can be several capability generations ahead. What we need instead are dynamic guardrails that:

• enforce least privilege at the decision layer, not just the access layer
• support real-time policy updates
• include transparent observability into agent reasoning
• provide clear boundaries for autonomy, revision, and execution
• operate with zero-trust assumptions
• allow rapid remediation when agents drift into risky behaviour In other words: our governance must become as adaptive as the agents themselves. This is precisely why open stewardship matters: it enables a shared, evolving rulebook rather than a static one.

I’ve even seen this happen in several internal automation and innovation scenarios:

- Example 1: Engineers get access to approved LLMs and GitHub. While experimenting with LLM powered agents, they’re suddenly able to create issues, trigger pipelines, run test suites or kick off similar actions inside GitHub. Nothing malicious, just innovation moving faster than the permission model can keep up.

- Example 2: Teams experimenting with AI and agent features inside approved tools plug them into a project environment to prototype an idea. No logs flowing into monitoring, no data residency reviews, no permission checks— just a quick experiment and suddenly the project’s risk posture has changed, even though officially nothing had “launched”. Curiosity outruns governance, and the “POC” turns into something that needs to ship right away while governance scrambles to catch up.

AGNTCY gives the industry a rare chance to establish norms before the ecosystem is locked into fragmented, proprietary standards. As a founding member, our contribution is rooted in pragmatism:

• innovation must remain fast
• risk must remain low
• trust must remain uncompromised Achieving all three requires collective action. It requires structures similar to the Linux Foundation: neutral, open, governed by community, and designed for long-term resilience.

At Orium, we’ve always been a company that moves quickly. But over the past year, we found ourselves accelerating even faster as agent-powered tooling entered our internal workflows. Every time we pushed forward, we saw the same pattern: the technology was outpacing the frameworks around it. Policies that made sense last quarter suddenly felt outdated. Automation grew more capable than the permission structure it lived inside.

It became clear that the only sustainable path was a shared one. Joining AGNTCY wasn’t about joining another industry group, it was about working alongside others who were running into the same challenges we were. When the future is arriving faster than governance can keep up, you don’t wait for someone else to define the rules. You help build them.

The question of “Who governs the agents?” isn’t philosophical. It’s operational, technical, and above all, urgent. Because the answer cannot be “whoever builds them.”

The answer must be: all of us, through transparent, open-source governance that ensures the Internet of Agents remains safe, fair, interoperable, and trustworthy.

AI agents will redefine software, commerce, and customer experience. Our responsibility is to ensure they don’t outpace our guardrails, our ethics, or our collective accountability.