Why Less Autonomous AI Is Actually More Effective in Enterprise

The Counterintuitive AI Strategy That Saved 1,500 Hours

Here’s something that sounds backwards: Morgan Stanley cut its riskiest reconciliation job in half by making its AI agents less autonomous. Not more. Less.

That’s not a typo. The financial giant deployed an agentic system called FIXR to handle profit-and-loss reconciliation across its global trade desks. The result? About 1,500 hours saved per week across roughly 100 controllers. But the secret sauce wasn’t giving the AI more freedom. It was keeping humans tightly in the loop—and systematically converting their decisions into repeatable rules the system could apply on its own.

As covered by VentureBeat, Managing Director Todd Johnson described the approach at a recent VB AI Impact event: “It’s much more like a co-worker than a copilot.” Think about that for a moment. In an industry obsessed with pushing AI to do more, Morgan Stanley found success by pulling it back.

What Morgan Stanley built

Every trading day, Morgan Stanley’s controllers perform a critical (and time-sensitive) task: reconciling P&L across Finance, Risk, Operations, and Trade Capture systems. Hundreds of thousands of data attributes need to match. When they don’t—these are called “breaks”—controllers must manually investigate each one, decide on adjustments, and sign off before the morning deadline.

Previously, this could take up to six hours for a single book. Now? Two to three hours. The system doesn’t replace the controller. It works with them, proposing resolutions based on learned rules, asking for help when uncertain, and flagging items that need human investigation.

Multiple agents collaborate behind the scenes. One interprets past guidance to develop start-of-day resolutions. One learns from controller behavior and documents the rules they apply. One converts repeated patterns into durable, automated logic. Over time, the system auto-clears familiar breaks, suggests solutions for new ones, and continuously improves.

But here’s the key: humans never leave the loop. They review, approve, or correct every recommendation. Those decisions then feed back into the system, making the next run smarter.

Why High-Stakes Work Needs Low-Autonomy Agents

Why does less autonomy work better? The answer lies in understanding what enterprise AI autonomy agentic systems actually cost—and what they risk.

The economics of determinism

Johnson and his team made a deliberate choice: limit how much of the workflow depends on the model’s judgment. Why? Because deterministic workflows are cheaper and more controllable.

“If you have an opportunity to make things very prescribed and repeatable, that’s cheaper in terms of token consumption, it’s more repeatable in terms of controls—and have the LLM do the stuff where you don’t need that kind of deterministic workflow,” Johnson explained.

This is a crucial insight for developers building enterprise AI systems. Every token costs money. Every probabilistic output introduces risk. When you’re dealing with financial reconciliation—where a single error could mean misstated earnings—letting an LLM “judge” every decision isn’t just expensive. It’s irresponsible.

By contrast, fixed rules cost almost nothing to execute. They’re predictable. They’re auditable. And they scale without burning through your API quota.

When to use rules vs. LLM judgment

So how do you decide what to automate deterministically versus what to hand to the LLM? Morgan Stanley’s approach offers a practical framework:

• Repeated patterns become rules. When the same break gets resolved the same way multiple times, codify it. No need to ask the model again.
• Novel situations get LLM input. The model suggests solutions for unfamiliar breaks, but humans still approve.
• Uncertainty triggers escalation. When the system isn’t confident, it asks for help instead of guessing.

This isn’t dumb automation. It’s smart distribution of cognitive load based on repeatability and risk.

The Human-in-the-Loop Feedback Engine

The real innovation isn’t the AI. It’s the feedback loop. Morgan Stanley built what amounts to a continuous learning system—where human decisions become codified rules over time.

From exceptions to rules

Here’s how it works in practice: A controller resolves a break a certain way. The system notes that decision. If similar breaks resolve the same way repeatedly, the system converts that pattern into a fixed rule.

Over weeks and months, the system handles more and more items automatically—not because it was programmed to, but because it learned from human behavior. Johnson put it this way: “Over time you’ll see more and more of those items resolved in an automatic way.”

This is fundamentally different from traditional automation. RPA (robotic process automation) follows rigid, pre-programmed rules. This system discovers rules from human behavior. It’s automation that learns.

Governance without bottlenecking

But here’s the challenge: how do you maintain accountability without creating a bottleneck where humans check everything?

Morgan Stanley’s solution is elegant: humans review and approve decisions, but that review itself trains the system. The feedback loop is the governance mechanism. When a controller corrects the system, that correction becomes training data. The system gets better. Humans spend less time reviewing the same issues.

“One of our strong principles in our AI governance generally is that there always has to be human accountability, even if there’s a degree of automation,” Johnson noted. But that accountability doesn’t mean checking everything manually. It means the human owns the outcome—even when the agent helps.

There’s also a governance layer around “performance.” If a senior controller works with a junior controller, they don’t relinquish responsibility just because an agent is involved. The same principle applies here: humans own the results.

What This Means for Developer AI Implementations

What does this mean for you, building AI systems for enterprise? More than you might think.

The process-before-AI principle

Johnson’s team ran a “very thorough” process intelligence assessment before touching any AI. They mapped workflows, identified bottlenecks, and asked a critical question: Is the answer agents, traditional automation, or just re-engineering an inefficient step?

“If we can fix that first before we add agents to the problem, then we really will be transforming the opportunity,” Johnson said.

This should sound familiar to developers. Before reaching for an AI solution, ask: Can I solve this with deterministic code? Can I optimize the process first? AI is powerful, but it’s also expensive and unpredictable. Sometimes a better algorithm beats a bigger model.

Building for iteration

The second lesson is design-oriented: build for continuous improvement from day one.

Morgan Stanley chose P&L reconciliation partly because it happens globally—hundreds of controllers across the Americas, Europe, and Asia do this work. The extensibility was deliberate. Prove it in one area, then extend it.

Your next agent project should follow the same pattern. Start with a bounded, high-impact use case. Build feedback mechanisms from the beginning. Design for iteration.

One “depressing” thing about agentic AI, as Johnson joked, is that it requires ongoing training. Models change. Context shifts. You’ll never say “we’re done” and let it run forever. Accept that. Build systems that adapt.

The Bigger Picture: Beyond the Autonomy Myth

Morgan Stanley’s experience isn’t an outlier. It’s a pattern.

VentureBeat’s recent VB Pulse survey found that nearly three-quarters of respondents saw little to no ROI from custom model fine-tuning—describing a “sandbox graveyard” of AI projects too costly to maintain. Only two of 87 enterprises had active monitoring and alerting for model failures.

Process-first approaches like Morgan Stanley’s seem more sustainable than chasing bespoke models. The future of enterprise AI autonomy agentic systems might not be about building smarter, more independent agents. It might be about building smarter relationships between humans and agents.

The lesson? Don’t automate for autonomy’s sake. Automate for outcomes. Sometimes, the smartest AI is the one that knows when to ask for help.