For a successful collaboration, we need to know the rules of the game. And when agents and humans collaborate, these rules need to be explicit, we cannot rely on some type of implicit understanding based on social rules known by the “players” and (some) “common sense”. Agents don’t infer social cues nor they don’t read between the lines (well, some humans don’t either but let’s say that for agents this is really beyond their capabilities).

If we want predictable and trustworthy human–agent collaboration, the rules must be explicit. Therefore, I believe it’s time to treat governance like we treat the rest of our (software) infrastructure: explicit, versioned, executable, and enforceable. In other words, governance as code (GaC). 

Similar to other parts of the development process that have been formalized and automated (e.g. Infrastructure-as-Code), GaC enables a better collaboration of agents (and humans with agents), including the possibility to execute policies and governance rules to make decisions automatically.

Some clear benefits of Governance-as-code:

1. Transparency: Humans and agents operate under the exact same rules. No hidden assumptions, no reliance on tacit knowledge. This can also increase the number of contributions to your project.
2. Fairness. Rules apply to everyone. And as they can be examined and debated. There may be biases (e.g. some actors, either humans or agents, with more power to vote) but they will be visible and with a purpose (e.g. to favour communities that were discriminated so far).
3. Scalability. As the number of agents grows, manual governance enforcement becomes impossible. Formal rules (and a rule engine) allow automated checking and enforcement.
4. Accountability and traceability. Every action decision can be tied to a transparent rule and to the events that triggered that rule, and logged for future revision.
5. Stability. Enforcing explicit governance prevents misalignment and unintended behavior, even if it was “an accident”

And this idea is not just theoretical. Concrete tools and languages are emerging to make governance as code a reality. While not massively yet adopted. more and more projects start to at least talk about how the project is governed. And we have provided even a concrete (domain-specific) governance language and runtime engine that enables you to:

• Write governance policies precisely.

• Monitor events produced by humans and agents (e.g., commits, comments, PRs on GitHub but also in any other platform you configure).

• Automatically apply the relevant governance rules (and generate the corresponding decision events when the rules are satisfied)

In this new agentic era, Governance must be code. Explicit, precise, executable, evolvable and explainable.

Start embracing Governance as Code and leverage the full power of humans and agents seamlessly collaborating in your project.