An AI agent can execute every tool call correctly and still break every enterprise rule. That warning, shared by Gabe Monroy, CTO at Workday, captures the central risk facing enterprise AI as autonomous systems move closer to real business actions.
Nearly every product pitch assumes agents, tools, and data are enough for enterprise AI deployment. They are not. The real challenge is making sure an agent operates lawfully, securely, and within the authority granted to it.
Correct Tool Calls Can Still Create Wrong Outcomes
Language models have important limits. A model has a training cutoff, cannot perform every calculation reliably, and cannot affect software systems by generating text alone. Tool calling addresses one part of that problem by allowing an agent to trigger an external action through a defined tool.
That action can become deterministic, but deterministic execution does not solve the governance problem. An agent may select and complete the correct tool call while still violating the rules that should control whether the action was allowed in the first place.
Consider the rules that shape enterprise decisions. An agent can bypass regional labor laws, tax withholdings, and worker classification checks because it does not inherently understand these rules. The technical success of the action does not prove that the business process was lawful.
This creates a gap between can the agent perform the action? and should the agent perform the action? Tool calling answers the first question. Enterprise governance must answer the second.
Why External Patches Create Fragmented Control
The default engineering response to lawless behavior is to patch vulnerabilities externally. Teams may add checks around the agent, restrict certain tools, or place controls in separate systems, but each added patch creates another part of the governance structure that must be maintained.
That approach leads to maintenance costs and fragmented governance. The agent, its tools, and the policies controlling them no longer operate as one connected system. Each layer can hold part of the context needed to make a lawful decision, yet no single layer necessarily has the complete picture.
To make an agent lawful by design, enterprise safety must be wired directly into the inference engine and execution runtime. The controls cannot sit at a distance from the action they govern. They must travel with the reasoning process and remain connected to the enterprise state that gives those controls meaning.
That design requires several layers working together:
- A context engine assembles what the agent’s identity is entitled to see, including active records, current policies, and organizational context.
- A policy engine validates every agentic action against the business logic that governs human actions.
- An execution layer ensures external API calls carry the explicit authority and scope of the specific human the agent serves.
These layers turn safety from an external patch into part of the agent’s operating structure. They also connect an action to identity, authority, policy, and live business information before the action reaches an external system.
The Proximity Principle Puts Governance at the Center
Every critical guardrail depends on live enterprise state, such as the organizational graph, active entitlements, and business processes. If an inference engine sits far from that state, the guardrails lose integrity and speed because the system must work across a greater distance from the information governing the action.
The proximity principle states that AI inference should belong directly on the platform that governs it. Running AI inference on the platform that already provides enterprise governance is essential for lawful agents because the model can operate closer to the policies, records, authority, and processes that define acceptable action.
This principle changes how enterprise teams should evaluate AI agents. The question is not only whether a model can reason, call a tool, or complete a workflow. The question is whether the entire system can connect each decision to live enterprise state and validate that decision before execution.
That connection matters because business rules do not exist as isolated instructions. They depend on organizational context, current entitlements, active records, and the business processes governing human actions. An agent that lacks those connections may produce a technically valid result without producing a lawful one.
Gabe Monroy’s warning puts the issue in direct terms: “Your AI agents can execute every tool call correctly and still break every enterprise rule.” The statement shifts attention away from tool performance and toward the controls that surround every action.
Enterprise AI will move forward through agents that combine reasoning with integrated governance. The winning architecture will not treat compliance as a patch added after deployment; it will place policy, authority, context, and execution together on the platform that governs the work.
Based on
