When agents act on their own, governance has to live in the data layer
Our take
The rise of AI agents capable of autonomous action presents a fascinating, and potentially disruptive, shift in how businesses leverage data. As enterprises grant these agents the power to plan, decide, and act across systems without constant human oversight, a critical question emerges: how do we ensure responsible execution? This article, presented by EDB, rightly highlights a crucial point often overlooked in the excitement surrounding generative AI – the need to shift governance from abstract policies to executable controls embedded within the data layer itself. Rethinking Data Visualisation: A UX Approach To Dashboards That Actually Drives Decisions demonstrates the importance of user-centric design in data interaction, a principle that should extend to governing agent activity as well, ensuring transparency and accountability. Orchestration is the new challenge for CX in the age of AI agents further underscores the complexity of managing increasingly autonomous systems, particularly in customer-facing applications.
The traditional approach of layering guardrails—instructions, policies, and monitoring—above the AI model is fundamentally flawed. As the article compellingly argues, these controls are only as reliable as the agent's output predictability, a quality inherently compromised by autonomy. Waiting to review an action *after* it's happened is simply too slow in a world where agents operate in milliseconds across multiple systems. EDB’s emphasis on embedding governance directly within the data layer—at the point of access and action—is a pragmatic and necessary evolution. This isn't about stifling innovation; it’s about creating a robust foundation that allows enterprises to confidently deploy AI agents at scale, knowing that data security and compliance are intrinsically woven into the operational fabric. The analogy of the car door is particularly apt—a blanket rule forbidding opening a car door is nonsensical, but a system that dynamically assesses context and enforces access based on that context is both intelligent and secure.
The shift to data-layer governance isn’t about introducing entirely new mechanisms. Rather, it’s about leveraging existing controls—role-based access, column-level security, audit trails—in a more intelligent and automated way. The key difference lies in treating agents as first-class principals, defining their purpose at the session’s outset, and integrating that purpose into the policy evaluation process. This approach offers a significant advantage: it decouples governance from the specific architecture of the AI agent, ensuring that controls remain effective regardless of how the agent is built or evolves. The focus on open-source Postgres, as highlighted by EDB, further strengthens this approach, providing enterprises with greater control over their data and governance frameworks, avoiding vendor lock-in and facilitating compliance with stringent regulatory requirements.
Ultimately, the success of AI agent adoption hinges not on the sophistication of the models themselves, but on the robustness of the governance mechanisms surrounding them. The imperative is clear: enterprises must move beyond hoping for good behavior and instead construct systems that actively prevent undesirable actions. EDB’s proposed framework, with its emphasis on enforceability, auditability, and data sovereignty, offers a compelling roadmap for navigating this evolving landscape. The question now is: how quickly will organizations adapt to this paradigm shift, recognizing that proactive data-layer governance is not a constraint on innovation, but rather the very foundation upon which responsible and scalable AI deployments are built?
Presented by EDB
As enterprises give AI agents more autonomy — the ability to plan, decide, and act across systems without a human approving each step — a hard question moves to the center of every architecture review: When an agent tries to complete an action that it was never authorized to do, what actually stops it?
These are your agents, running on your models, touching your data in your infrastructure — and the responsibility for what they do sits with you. That responsibility can’t be met in hindsight or with a set of abstract policies that live on paper but not in practice. Agents need rules in the context of the moment, because they don’t exercise overriding judgment of their own actions.
Consider a simple rule: Never open the car door. Followed literally, an agent could never get in or out of the car at all. But if you change the context (the car has just crashed, there’s a fire, someone is hurt and needs to get out), then the rule you actually want is the opposite. Context in the moment is everything. We are asking agents to do intelligent things; that requires intelligent rules.
The instinct is to add guardrails around the agent: instructions, policies, and monitoring layered above the model. Those mechanisms matter, but they share a structural limit: The car-door rule is plausible right up until the moment you actually have to decide whether to open the door. Controls at the agent layer are only as reliable as the agent’s output is predictable, and autonomy is precisely the property that makes that output hard to predict. Governance that depends on reviewing an action before it happens cannot keep pace with a system that acts in milliseconds, across many systems at once.
Governance has to become executable, and enforced where agents actually do their work: at the operational data layer, in the context, and exactly at the moment it is happening.
The data layer is the enforcement point
Agents create value by touching data. They query it, retrieve it, transform it, and increasingly act on it. A policy that says an agent should not reach a certain class of data is meaningful only if the system can deny that access at the moment the agent requests it. Additionally, a principle that says AI must be auditable is meaningful only if the organization can reconstruct what the agent did, what data it touched, which user it acted for, and what resulted. When governance lives at the data layer, it holds regardless of how the agent was built or how it behaves, because the control is a property of the database itself, not a promise made by the agent.
Agent behavior may be probabilistic. Governance cannot be
The enterprise should not rely on a model choosing to follow policy. The policy has to be enforced by the system. That is the difference between hoping an actor stays in bounds and constructing bounds it cannot cross to begin with.
The controls that make this real are ones many enterprises already run at the data layer: role- and attribute-based access, row- and column-level security, classification and masking, policy as code, and complete audit trails.
What agents change is not the mechanism, but who the mechanism has to recognize. Identity management has to treat the agent as a principal in its own right, with its own identity and a purpose declared when the session opens.
Once purpose is bound to identity, the policy engine can evaluate it the same way it evaluates role or department today, and the record of what happened can capture not just who acted and what they touched, but what they declared they were there to do.
In practice, this resolves into nine controls, grouped under three imperatives:
Enforce it
Role- and attribute-based access control enforced at query time, for agents as well as users
Dynamic column masking driven by the same policy path
Agent identity as a first-class principal, with declared purpose bound at session start and the acting user preserved
See it and prove it
Classification and tagging that drives policy
Session-level audit logging that records which agent acted, for which user, and under what declared purpose
Lineage across pipelines, so a result can be traced back to the request that produced it
Unify and harden
Centralized, portable policy management
Encryption at rest and in transit
Consistent enforcement across on-prem, cloud, and sovereign or air-gapped environments
“Declared purpose is what makes the difference. It becomes an attribute the access layer already understands, evaluated in the same policy path as role and row-level security. The enforcement mechanism does not change. What changes is that the agent's purpose is part of what it evaluates, and part of what the record proves afterward,” says Priyanka Jain, VP, product management, data & AI governance, EDB.
Wherever you are in your AI adoption journey, enforcement at the data layer is what lets you move faster rather than slower. The controls are already in the database. The difference is that agents now have to pass through them.
A digital leash, not a locked door
The goal is not to stop agents from doing useful work. It is to define how far an agent can go, what it can touch, what it can change, what requires escalation, and how the organization can reconstruct events if something goes wrong. Governed this way, agents are identified, scoped, monitored, and auditable. The enterprise can adopt them faster, because security, risk, and leadership teams trust the operating model underneath.
Open, sovereign, and enforceable at the source
Built on open source Postgres, this open foundation keeps enterprises in control of where their data lives, who can reach it, and under what policy, without ceding governance to a layer they don’t own or can’t inspect. For regulated industries, that combination of data sovereignty and source-level enforcement isn’t a nice-to-have; it’s the precondition for putting agents into production at all.
Agentic systems will keep getting more capable and more autonomous. That is a reason to be deliberate about where control lives, not a reason to slow down. The enterprises that enforce governance at the data layer can move aggressively on AI, because the thing protecting their data is more than just wishful thinking.
EDB Postgres AI is an open, enterprise-grade sovereign data and AI platform that unifies transactional, analytical, and AI workloads — with governance enforced where the data lives. For the full framework, see EDB’s white paper Governing Agentic AI at Enterprise Speed.
Max Romanenko is Chief Technology Officer at EDB.
Sponsored articles are content produced by a company that is either paying for the post or has a business relationship with VentureBeat, and they’re always clearly marked. For more information, contact sales@venturebeat.com.
Read on the original site
Open the publisher's page for the full experience