What if I told you your AI agents are going to fail in production?

Well, at least statistically speaking. According to Gartner and MIT, many AI agent projects will never make it to production, which is why AI projects fail to impact P&L.

So is that it? Better keep doing business as usual and ignore the AI revolution? Not quite. AI agents can be a huge benefit for your business if you know what to do to get AI agents in production (and most importantly, what NOT to do).

2025 is the year of AI agents. Enterprises are wiring them into workflows, and new agentic AI models like GPT-5 signal abundant intelligence at near-infinite scale.

So many Fortune 500 businesses have started initiatives consisting of internal teams building DIY agent automations. They probably managed to show a great demo and first results. But then the hard reality check kicks in: what about deployment? Security? Access to data and context? AI data governance? PII and AI privacy? Ownership? AI agent guardrails?

The list of questions is long, good answers are scarce.

I hit the same walls myself building a real system. In the last few months I have been working on a project that brings the power of AI agents to BI and data analysis at scale. And boy, oh boy was I naive when I started working on it. But this also forced me to dive deep into the agentic AI rabbit hole and come out at the other end with not just knowledge, but a working system.

Probably one of the biggest a-ha moments for me was when I realized you cannot force LLMs (and thus AI agents) to do anything. You just can’t. It is an illusion that we live in. In real-world, complex scenarios with lots of context and contradicting requests, agents try their best to satisfy the user’s prompt. But they might make the wrong decision or decide not to do that thing they were supposed to do. And there is no “switch” or setting you can use to suddenly make them do the thing. Scary, isn’t it?

That is when the realization kicks in: you must treat projects that use AI agents the same way you treat any other IT or software project. Probably you need even more guardrails and checks than with traditional methods and code. And for sure, you need specialized knowledge about how LLMs work and behave, plus strong AI governance. It is not enough to read the API docs.

Access to context is the single biggest challenge of all, when it comes to building systems with AI agents.

So what can be done to increase the chances of success?

I recommend having a clear operating playbook, a set of rules that are stated explicitly so everyone on your team is on the same page. Be wise about the process you want to automate with agents and keep changes small at first. Pick a process that has a measurable KPI that you can track before and after adding agents to the game.

Agentic automation is quite different from traditional workflows. The more specific steps you define for an agent, the less benefit you’ll be getting from using AI at all. It is going to be more expensive and slower than just programming the solution. This is why you need to carefully plan the behavior of the agent by combining the right prompt with the necessary tools for it to make autonomous decisions, instead of following step-by-step instructions. In practice, this is context engineering. Letting go definitely feels counterintuitive when working with software.

If you want an agent to be really helpful, it needs to get the right context, too. And the context, not prompts, will make or break the agentic capabilities, and by extension, those of your system.

Your agents must get enough context to be helpful, but this context must be well-governed, providing the least necessary levels of permission. The system needs to be ruled by clear, auditable policies. The data layer requires a bunch of new primitives and concepts that allow “nameless” and “shapeless” instances of LLMs to become identifiable agents with secure and short-lived access to all the information and capabilities they need to do real work, including least privilege for AI agents and row-level security (RLS) where appropriate.

Here is the AI agent playbook that consistently moves agents from demo to P&L:

• Pick one process with a single KPI owner and baseline it (make sure the KPI is really clear to optimize for and not dependent on many external factors)
• Stick to a single agent first. Define the agent’s role and general behavioral rules to get AI agents in production safely
• Consider the context from the beginning: sources, least-privilege access (least privilege for AI agents), row-level security (RLS), compliance rules
• Tooling contract: what the agent may call, focus on reversible and replayable actions in the first iterations, plan the tools accordingly (normally tools are just regular code and SDKs or APIs) and define AI agent guardrails
• Do not focus on memory and learning loop during your first iterations; learn from observing the system first
• Release plan: deployment strategy, human in the loop for AI agents, clear kill switch readily available
• Observability is key: debug logging and a full audit.

Anti-patterns are important to mention too: over-scripted flows, unmanaged context sprawl, no kill criteria, agent washing (workflows disguised as agents).

Anti-patterns to avoid:

• Do not script every step; if you can hardcode it, you do not need an agent.
• Do not start broad; begin with one task, one KPI, one owner.
• Do not give blanket access; enforce least privilege with short-lived, audited credentials and row-level security (RLS).
• Do not ignore context hygiene; define sources and authority up front.
• Do not skip a rollback plan and a clear kill switch.

Crossing the chasm is not a bigger model. It is better context, better governance and controls, and better operations. Make sure to have these discussions within your teams right from the start. This will avoid early failures (although mistakes will still happen) and help your team build up confidence inside the organization.

If you remember nothing else, remember this triad: context, controls, operations.