I recently joined AI and data leaders from AT&T, SAP, and Rubrik for an insightful panel on operationalizing agentic AI. The discussion underscored a clear shift across enterprise environments: the debate over whether AI agents can act autonomously is over. In production, autonomous AI is already a reality.
Today, the real challenge for modern enterprises is maintaining control, governance, and visibility as agentic workflows scale. Below are the key patterns, best practices, and lessons learned from the front lines.
The "Smart" Half Is Solved. The "Teammate" Half Isn't.
Building an intelligent Enterprise AI is no longer the primary bottleneck as enterprises now need to focus on turning those models into reliable enterprise "teammates" is. At Revefi (a platform dedicated to agentic AI, LLM observability, and data cost optimization) we work alongside AI teammates every day.
Two years ago, we introduced Raden, our flagship AI agent. Today, Raden is not a single agent, but a full portfolio of specialized AI agents working as a cohesive team:
- Continuous Telemetry:
Specialized agents monitor Agents, LLM performance, costs, and telemetry across major data ecosystems like Snowflake, Databricks, and Google BigQuery. - Domain Expertise:
Each agent independently evaluates specific domains, including data quality, system performance, and infrastructure spend. - Flexible Execution:
Agents act as copilots by recommending optimizations, or as autopilots by executing fixes autonomously when authorized.
It is my view that the industry has the emphasis backwards: everyone is racing to make agents smarter, and smart is the easy half. A trusted teammate shows their work. They know the boundaries of their role. They ask for help before doing something risky. They earn more responsibility by being right, repeatedly, on the record. Each quality has to be deliberately engineered, and when you list what that engineering consists of, you have written the agenda of this panel: governance, observability, and human control.
Teammates don't stay solo. Where we are heading is AI teams, multiple specialized agents with defined roles, coordinating with each other and with the humans they serve. That is how Raden itself is built, as a portfolio of specialized agents, each with its own scope and its own track record.
From Automation to Agency: Shifting Judgment to Runtime
What truly separates agentic AI systems from traditional workflow automation? It all comes down to where judgment resides.
Standard automation simply executes human judgment that was predetermined and hardcoded into a workflow. Agentic AI, however, exercises judgment at runtime. It takes a goal, formulates a multi-step plan, selects appropriate tools, analyzes real-time results, and continuously adapts its strategy.
The operational impact of this shift is profound:
- Traditional Workflows:
You validate a deterministic tool once and trust it until external conditions change. - Agentic Teammates:
You cannot validate autonomous AI just once. Because decision-making happens inside the machine in real time, validation must also occur continuously at runtime.
AI Governance as Onboarding, Not Paperwork
Enterprise agentic AI governance models often feel over-engineered. In practice, the most effective blueprint is already used in Enterprises: how high-performing teams onboard new employees.
By adapting traditional onboarding for Agents, organizations can establish control across three core layers:
- Unique Identity & Credentials:
AI agents must act as first-class digital principals with dedicated credentials and explicit audit trails, never using shared or borrowed service accounts. Clear accountability requires precise attribution. - Code-Based Working Agreements:
A deterministic policy layer must operate between an agent’s proposed plan and its actual execution. This layer checks actions against budget caps, blast radius, data sensitivity rules, and regulatory limits. The agent reasons; the policy layer authorizes. - Graduated Autonomy:
Grant trust incrementally. Start with read-only diagnostics, transition to reversible low-stakes tasks, and expand execution authority only as performance is proven—moving intentionally from copilot to autopilot.
Adaptive Guardrails: Governing the Plan, Not Just the Step
Static guardrails have a fundamental flaw: they evaluate actions in isolation, missing cumulative risk. A sequence of ten individually safe decisions can still result in a critical system outage.
Preventing runaway behavior requires evaluating the full picture through three distinct mechanisms:
- Plan-Level Assessment:
Evaluate the total impact of an agent's multi-step plan before execution, factoring in combined costs, overall blast radius, and multi-system dependencies. - Dynamic Resource Budgets:
Set strict session allowances for total spend, change frequency, and risk exposure. When a budget depletes, human check-ins are triggered, catching unexpected behavior that static rules miss. - Context-Aware Policy Enforcement:
Governance rules must adapt to real-time business conditions. The threshold for an action should be significantly stricter during critical periods like month-end close or active incidents than on a quiet afternoon.
Observability: The First Duty of a Teammate Is to Show Their Work
This part of the discussion is close to Revefi. Revefi is an observability company that ships an agent, so we hold Raden to the same standard we hold a production AI, ML and data pipelines. The final output is the least informative thing an agent produces. By the time an output is wrong, the failure usually happened three steps earlier, in a belief the agent formed from stale telemetry or a misread tool result. If the belief was never recorded, the behavior cannot be debugged, and the agent cannot credibly be trusted with more.
The instrumentation baseline I recommend, includes:
- Decision traces.
What the agent observed, inferred, considered, and rejected, stored structured and queryable rather than buried in logs. - A complete tool-call ledger.
Every external call with parameters and results. It is both the forensic record and the evidence base for right-sizing permissions. - Memory and state snapshots.
What the agent believed at each step, because drift in behavior almost always traces back to a stale or corrupted belief. - Plan revisions.
A teammate who keeps changing the plan mid-flight is telling you something. Both a volatile environment and the agent's own confusion deserve an alert. - Cost governance and optimization.
The missing pieces in most instrumentation stacks. An agent's reasoning loops carry a real cost profile, and it belongs in the same pane of glass as its behavior.
Human Control That Doesn't Kill Velocity
Great teams run on trust plus escalation. Human-in-the-loop is where many deployments quietly fail, because the debate treats it as a dial between approve-everything and approve-nothing, and both ends break for the same reason they break on human teams. Micromanagement doesn't scale, and it decays: a person facing a hundred routine approvals a day stops reading them, which is worse than no control because it still looks like control on an audit report. Full delegation without escalation paths lets small mistakes compound in silence. The division of judgment that works mirrors healthy teams:
- Approve the irreversible.
Pre-action approval for the small set of high-consequence, hard-to-undo actions, with the agent's reasoning and projected impact visible. A reviewer who can't see the why is a formality. - Escalate the ambiguous.
The agent operates freely inside its envelope and raises its hand when confidence drops or policy is unclear. Raising your hand at the right moment is exactly what good teammates do. - Review the sampled rest.
Post-action audits, made cheap by the observability layer, become the evidence base for widening autonomy over time.
From Pilot to Production: The Gaps Are Operational, Not Technical
Pilots stall because teams hired a brilliant engineer and skipped the onboarding. The gap is never intelligence; it's everything that makes intelligence usable by a team. A pilot that succeeds 90% of the time feels magical in a demo. In production, your entire operational life is the other 10%.
Watching customers take Raden into production, the gaps are consistent, and almost none are model problems:
- No clear owner.
A production agent needs a named operational owner, an on-call rotation, runbooks, and authority over the kill switch. My litmus test fits in one question: who gets paged when the agent misbehaves at 3 a.m.? No name, no launch. - Evaluation that doesn't survive reality.
Curated demo scenarios must give way to continuous evaluation on live traffic, regression suites for judgment, and canary rollouts for every prompt, policy, and model change. Version the agent like code, because it changes like code. - Unbudgeted cost.
Agents that reason in loops consume tokens and compute in ways pilots never reveal. Per-outcome cost telemetry has to exist from day one. Ironically, one of Raden's main jobs is optimizing data platform spend, so we point Raden's own cost analytics at Raden.
Keeping AI Teams Aligned: Feedback as an Operating Discipline
Alignment is not a launch-day property. It is the feedback culture you would build around any teammate: fast checks on commitments, honest signals at the moment of judgment, and retros that update the working agreements.
.jpg)
We think that four loops cover it:
- The predict-observe loop.
Every action carries a prediction of its impact, and telemetry confirms or refutes it, catching misalignment automatically. It is the heartbeat of trust. - The human activity signal.
Your organization is already generating world-class alignment data every single day, and most of it is probably being thrown away. Every approval, rejection, override, and escalation outcome is a labeled example of where the agent's judgment diverges from yours. The audit trail you built for compliance is secretly your best training set. - Review the working agreements.
Audit the policies themselves, not just compliance with them. Environments drift, and an agent perfectly obeying stale policy is misaligned with a paper trail. - Replay before release.
Test agent changes against a library of recorded production scenarios, including your ugliest past incidents. Regression-test the judgment, not just the code.
Done well, alignment stops looking like philosophy and starts looking like what it actually is: good team management, practiced at machine speed.
Closing View
Each panelist closed with a single principle for keeping autonomous AI controllable at enterprise scale. Mine is the sentence I consider the operating contract between humans and their AI teammates, and I gave it a corollary that I consider non-negotiable: “Autonomy must be earned, never assumed.”
Additionally, humans must retain the ability to revoke autonomous AI capability, i.e., Have a kill switch.
Key Takeaways
- Treat agents as smart teammates. Showing work, knowing scope, escalating, and earning trust do not come from the model; they have to be engineered, and they are the difference between the 97% who struggle and the teams who scale.
- Govern like onboarding: scoped identity, a policy layer between intent and execution, and autonomy granted in increments. Make restrictive architecture your first governance layer.
- Replace static guardrails with plan-level review, depleting budgets, and context-aware policy.
- Instrument how the agent thinks, then run anomaly detection on the agent itself. Trust becomes a metric you can put on a dashboard.
- Put human attention where consequence lives: approve the irreversible, escalate the ambiguous, review the sampled rest.
- Close the loop from day one: run the predict-observe loop on every action, capture the human activity signal you are currently discarding, review the working agreements, and replay before every release.
- Autonomy must be earned, never assumed. And humans must retain the ability to revoke it: have a kill switch.
You can watch the entire webinar on demand next week.
