How Much Freedom Do We Give AI Agents?
AI agents — software that can take actions on your behalf, like writing code, sending emails, or searching the web — are no longer a futuristic concept. They're here, and people are using them every day. But a big open question remains: how much independence should we actually give them?
Anthropic, the company behind Claude, just published a fascinating study that digs into millions of real-world interactions between humans and AI agents. Instead of theorizing about what agents could do, they measured what's actually happening in practice. Here's what they found, and why it matters.
What Is an AI Agent, Anyway?
Before diving into the findings, let's clarify what we mean by "agent." In this context, an AI agent is an AI system that doesn't just answer questions — it can do things. It can run code, call APIs, edit files, and interact with other software. Think of it as the difference between asking someone for directions versus handing them the car keys.
Anthropic studied two main data sources: Claude Code (their own coding assistant that developers use daily) and their public API (which thousands of companies use to build their own AI-powered tools). Together, these gave them both a deep and broad view of how agents behave in the real world.
Agents Are Working Independently for Longer
One of the headline findings is that AI agents are running for longer stretches without human intervention. In Claude Code, the longest sessions (the top 0.1%) nearly doubled in duration over just three months — from under 25 minutes to over 45 minutes of uninterrupted autonomous work.
What's interesting is that this increase was gradual. It didn't jump with each new model release, which suggests it isn't just about the AI getting smarter. It's also about people becoming more comfortable letting the AI work on its own, and about the product improving around the edges.
The median session is still short — about 45 seconds — so most interactions are quick back-and-forth exchanges. But the trend at the top end signals a meaningful shift in how people are starting to use these tools for bigger, more ambitious tasks.
Trust Builds Over Time — But So Does Vigilance
Perhaps the most nuanced finding is about how people's behavior changes as they gain experience with AI agents.
New users tend to approve every single action the AI takes — a kind of "trust but verify each step" approach. But as users rack up more sessions, they increasingly switch to auto-approve mode, letting the AI run freely without asking permission for each action. Among new users, about 20% of sessions use auto-approve. For experienced users (750+ sessions), that number climbs to over 40%.
Here's the twist: experienced users also interrupt the AI more often, not less. This seems contradictory at first, but it actually reflects a smarter oversight strategy. Instead of micromanaging every step, experienced users let the AI run and then step in when something looks off. It's like the difference between a new manager who reviews every email before it's sent versus a seasoned one who trusts their team but keeps an eye on the important stuff.
This suggests that effective oversight isn't about controlling every action — it's about being in a position to intervene when it matters.
The AI Knows When to Ask for Help
One of the more surprising findings is that Claude stops itself to ask questions more often than humans interrupt it — especially on complex tasks.
On the hardest tasks, Claude Code pauses to ask for clarification more than twice as often as on simple ones. The most common reasons it stops? To present choices between different approaches (35% of the time), to gather diagnostic information (21%), or to clarify vague requests (13%).
Meanwhile, humans mostly interrupt to provide missing technical context (32%), because the AI seemed stuck or slow (17%), or because they got enough help to continue on their own (7%).
This is a meaningful safety property. An AI that recognizes its own uncertainty and asks for help rather than plowing ahead is inherently safer than one that always assumes it knows best. Anthropic actively trains Claude to behave this way, and they encourage other AI developers to do the same.
Most Agent Actions Are Low-Risk — But the Frontier Is Expanding
When Anthropic looked at what agents are actually doing across their API, the picture was largely reassuring:
- 80% of actions come from agents with some form of safeguard (like restricted permissions or human approval).
- 73% appear to have a human in the loop in some way.
- Only 0.8% of actions are irreversible (like sending an email to a customer).
The vast majority of agent activity is in software engineering — nearly 50% of all tool usage. This makes sense: code is easy to test, review, and reverse if something goes wrong, making it a natural fit for AI autonomy.
But agents are starting to appear in higher-stakes domains too: healthcare, finance, cybersecurity, and customer service. While these uses are still small in volume, they carry much higher consequences if something goes wrong. A bug in code is annoying; a mistake in a medical record or financial transaction is a different story entirely.
What Does This Mean for the Future?
Anthropic draws several important conclusions from this research:
There's a "deployment overhang." The autonomy that AI models are capable of handling exceeds what they're given in practice. External evaluations suggest Claude can handle tasks that would take a human nearly 5 hours, but in real usage the longest autonomous stretches top out around 45 minutes. People are being cautious, which is probably wise — but it also means agents could be doing more.
One-size-fits-all rules won't work. Mandating that humans approve every single AI action would create friction without necessarily improving safety. The research shows that experienced users naturally develop effective monitoring strategies that don't require step-by-step approval. Good oversight is about being able to intervene when needed, not about rubber-stamping every action.
We need better monitoring infrastructure. Right now, even Anthropic can't fully see what happens with agents built on their API. They can observe individual actions but can't always stitch them together into coherent sessions. Building privacy-preserving tools to monitor agent behavior in the real world is an important next step for the entire industry.
Training AI to know its limits is a safety feature. Models that recognize uncertainty and proactively ask for help provide an important layer of protection that complements external safeguards like permission systems.
The Bottom Line
We're still in the early days of AI agents. Most of what they do today is relatively low-risk, concentrated in software engineering, and supervised by humans. But the trajectory is clear: agents are taking on longer tasks, operating in more domains, and being granted more independence over time.
The encouraging news is that this isn't happening recklessly. Users build trust gradually. AI systems are learning to flag their own uncertainty. And the research community is starting to measure what's actually happening rather than just speculating about what might.
The key insight is that autonomy isn't just a property of the AI — it emerges from the interplay between the model, the user, and the product design. Getting that balance right will be one of the defining challenges as AI agents become a bigger part of how we work.
Source: Measuring AI agent autonomy in practice — Anthropic, February 18, 2026.