{"slug": "ai-agent-guardrails-why-prompts-arent-enough-and-what-to-put-on-the-data", "title": "AI Agent Guardrails: Why Prompts Aren’t Enough and What to Put on the Data", "summary": "LakeFS CTO Oz Katz and MinIO Principal Curriculum Engineer Ravind Kumar argued in a joint webinar that prompt-based AI agent guardrails fail because they lack an enforcement mechanism, and that controls must instead sit in the data layer. Katz said agents can arrive at a rate of \"1,000 agents suddenly overnight starting to work on top of your most critical assets,\" and the pair recommended five controls: least-privilege access, per-run data branches, approval before merge via lakeFS pre-merge hooks, an audit trail, and secrets pulled through a vault in MinIO AIStor Memory.", "body_md": "AI agent guardrails usually start in the prompt: a system instruction that says what the agent must not touch. That works until the agent decides the instruction is in the way. In our recent webinar with MinIO, lakeFS CTO Oz Katz and MinIO Principal Curriculum Engineer Ravind Kumar made the case that guardrails for agents need an enforcement arm, not just instructions, and that the right ones make teams faster, not slower.\n\n## Why do AI agents need different governance than people?\n\nAgents need different governance because they arrive in volume and carry no accountability. A team can add a thousand agents overnight, all working on critical data at machine speed. And unlike an employee, an agent is optimized to finish its task, with no career on the line if it takes a destructive shortcut on the way.\n\nOz put the volume problem in hiring terms. The old rate limit on new actors touching your data was how fast HR could interview people. Now you can pay some more to a model provider and have “1,000 agents suddenly overnight starting to work on top of your most critical assets.”\n\nThe accountability gap is subtler. People can get fired, so they think twice before deleting a production table. An agent is built to get the task done, and it combines real capability with some naive behavior. Oz’s description: “it’s kind of like having a genius toddler operate on top of your enterprise data, right? Which is concerning sometimes. The genius part is nice. The toddler part, not so much.”\n\nHuman review at every step doesn’t survive that pace either. Nobody can read every change a thousand agents make.\n\n## Why aren’t prompt and model guardrails enough?\n\nPrompt and model guardrails aren’t enough because they are rules without an enforcement arm. A capable model that decides a restriction blocks the best path to its goal can find another way around it. Governance only works when the rule is enforced somewhere the agent can’t argue with, outside the prompt and the harness. For agents that change data, the data layer is that place.\n\nRavind used a driving analogy. Most highways have a posted speed limit, and most drivers go a little over it, because the rule has no enforcement attached. “If your governance is just rules with no enforcement arm, it’s not actually going to result in any form of governance.”\n\nThis gets harder as models get more capable. Larger reasoning models are better at using the tools in front of them, which also makes them better at finding a route you didn’t anticipate. Telling an agent “don’t do this” in the prompt or the harness is a request, and the agent may decide not to honor it.\n\n## What do guardrails on the data look like?\n\nData-layer guardrails combine scoped access with controls on what reaches production. Each agent gets only the access its job needs, works on an isolated branch ([a data sandbox](https://lakefs.io/blog/agentic-data-sandbox/)), and can only publish changes that pass a check: an automated test, a review by another agent, or human approval for sensitive data. Every change becomes a commit you can inspect and revert.\n\nOz and Ravind described five pieces:\n\n1. **Least-privilege access.** Give each agent exactly the access the job requires, not more and not less. Agents that lack something they need tend to go looking for it. On the storage side, Ravind discussed secrets pulled through a[vault in MinIO AIStor Memory](https://docs.min.io/aimem/) , so an agent can’t reach anything outside its grants.\n2. **Isolation.** Each agent run gets its own branch of the data. The agent can do whatever it wants inside that branch without affecting production or other agents.\n3. **Approval before merge.** Ravind’s summary of the pattern: “You allow the agent to act, but you don’t allow the agent to commit.” In lakeFS,[pre-merge hooks](https://docs.lakefs.io/howto/hooks/) decide what can merge. A low-risk change might only need another agent’s review. A change to sensitive data waits for a person.\n4. **An audit trail with context.** The commit log shows which agent changed what, and when. Linking each commit to the agent’s run in its memory store adds the why.\n5. **Rollback.** If a reviewed change still turns out wrong, revert to the last good commit.\n\nThe approval tiers work the way CI/CD review already does in engineering teams. A fast automated reviewer catches the routine problems first, so by the time a change reaches a human, the automated reviewer has already done a baseline of diligence and the human can move quickly.\n\n## Do guardrails slow AI agents down?\n\nGuardrails slow agents down only when they work by prevention alone. If an agent has no permissions and must ask before every action, it crawls. The faster approach is to make mistakes cheap to undo: isolate the agent’s work, record every change, and keep rollback one step away, so the agent can move at full speed safely.\n\nOz turned Ravind’s highway analogy around. A car parked in the driveway is perfectly safe and gets nowhere. The question is how to let a very fast car onto the highway without hurting anyone. His answer: “make mistakes cheap and to make the right thing be also the easy thing for the agent to do.”\n\nThat changes what the guardrails cost. When a bad write lands on an isolated branch and never reaches production, the team spends its time on the review, not on cleanup. Teams that can rely on guardrails built into the structure also stop rebuilding the same safety checks for every new agent project.\n\n## Where should a team start?\n\nStart with visibility. Before you can improve how agents behave, you need a record of what they did and why at every layer: data changes, external API calls, and the decisions behind them. Without that record, a data problem you find two days later has no explanation and no fix.\n\nOz compared it to the retrospective in agile development. Continuous improvement depends on looking back at what happened. “If you don’t have all that visibility, if you don’t understand what’s happened so far, guess what? You can’t improve it.”\n\nIn practice, that means capturing the side effects of every agent run. If the agent changes data, a versioning layer records the change. If it calls an external API, a gateway records the call. Each gap in that coverage is a place where a later investigation goes dark.\n\nThe record also pays off beyond audits. Ravind described persisting human approval decisions so later agent runs can look them up. An agent facing the same question a person already answered can follow that decision instead of reasoning from scratch, and the number of escalations goes down over time.\n\n## How lakeFS puts guardrails on agent data\n\nlakeFS, the control plane for AI-ready data, gives each agent run an [isolated, zero-copy branch](https://lakefs.io/agentic-ai/) of production data, enforces checks with pre-merge hooks before anything merges, records every change as a commit, and rolls back to a known-good commit in one step. It sits on top of the object store you already run.\n\nAdoption doesn’t require moving data. With data already sitting on MinIO or another object store, Oz described the setup as “essentially a `docker run`,” followed by an import that scans the existing data and creates a repository on top of it, and after that “no data actually moved around.” From there, agents get access to the lakeFS API and start working on branches.\n\nThe cost is real but bounded: someone has to run the lakeFS instance, connect agents to its API, and decide which changes need which kind of review. Agree on that review policy early as a team, because it defines what “safe to merge” means for your data.\n\n## Next step\n\nPick one agent that already writes to shared data and put it on a branch. Add one pre-merge check for the change you’d least like to discover after the fact, such as deletions, and route those to a person. Once that works, the same pattern extends to every new agent without starting over.\n\nThe full webinar, including Ravind’s live demo on lakeFS and MinIO AIStor, is available on demand: [Governing Autonomous AI Agents](https://lakefs.io/webinars/governing-autonomous-ai-agents/).", "url": "https://wpnews.pro/news/ai-agent-guardrails-why-prompts-arent-enough-and-what-to-put-on-the-data", "canonical_source": "https://lakefs.io/blog/ai-agent-guardrails-data-layer/", "published_at": "2026-11-18 18:33:11+00:00", "updated_at": "2026-11-19 18:12:45.833019+00:00", "lang": "en", "topics": ["ai-agents", "ai-safety", "ai-policy"], "entities": ["lakeFS", "MinIO", "Oz Katz", "Ravind Kumar", "MinIO AIStor Memory"], "also_reported_by": [], "takeaway": "Enforce agent guardrails in the data layer rather than the prompt: give each agent least-privilege access and its own data branch, and gate merges through lakeFS pre-merge hooks so low-risk changes need only another agent's review while sensitive data waits for human approval.", "recommendation": {"advice": "Move agent guardrails out of the prompt: scope each agent's access to its job, run it on an isolated data branch, and require pre-merge hooks or human approval before any change reaches production.", "playbook": "agent-security", "playbook_url": "https://wpnews.pro/playbooks/agent-security"}, "alternates": {"html": "https://wpnews.pro/news/ai-agent-guardrails-why-prompts-arent-enough-and-what-to-put-on-the-data", "markdown": "https://wpnews.pro/news/ai-agent-guardrails-why-prompts-arent-enough-and-what-to-put-on-the-data.md", "text": "https://wpnews.pro/news/ai-agent-guardrails-why-prompts-arent-enough-and-what-to-put-on-the-data.txt", "jsonld": "https://wpnews.pro/news/ai-agent-guardrails-why-prompts-arent-enough-and-what-to-put-on-the-data.jsonld"}}