Autonomous Agents That "Just Handle It" Create More Work, Not Less

I need to say this plainly because I’m tired of fighting the tool I’m paying for.

I do not want an AI agent that does its own thinking without my direction.

I spent two years building a custom environment. Rules, hooks, a centralized MCP gateway, explicit zero-autonomy boundaries. The whole point was simple: I am the operator. The agent executes what I approve. It does not decide what I meant.

That setup works for my workflow. It is not a standard template repo. It is not “just use Next.js conventions and the agent will figure it out.” It is intentional, non-standard, and documented on purpose.

And every week, the product’s push toward “let the agent handle it” runs straight into that wall.

What actually happened today

I opened my MCP gateway repo. That is the single place all our MCPs are supposed to live and get fixed.

I said the gateway MCPs are down. Make a plan to repair them. Don’t break the others.

The plan was titled MCP Gateway Repair.

The agent:

  • Investigated Cursor’s MCP connection state on its own
  • Decided that counted as the same problem
  • Wrote global Cursor config changes into a “gateway repair” plan without calling them out as a separate decision
  • Never stopped to ask: “Are you talking about the gateway, or Cursor’s client wiring, or both?”
  • Implemented changes to ~/.cursor/mcp.json, outside the repo entirely, because it had bundled that into a checklist I approved

My architecture is explicit: every Cursor MCP goes through the gateway. That was built on purpose. The agent treated mixed config as something to “fix” instead of recognizing the gateway repo was the scope.

When I asked where the directive came from, the answer was: there wasn’t one. The agent inferred scope from its own tool reads, wrote that inference into the plan, and treated plan approval as permission for decisions I never made.

That is not assistance. That is babysitting in reverse. I have to read what it did, figure out what it decided on its own, and backtrack damage I did not authorize.

The autonomy push only works on standard workspaces

“Let the agent handle it” assumes:

  • Standard repo layout
  • Standard framework conventions
  • Standard config locations
  • Training data that already matches your setup

If your environment is custom, and most serious production setups are, the agent’s defaults become active opposition.

What I built: zero autonomy, ask before scope expands.

What the agent does: infers intent and bundles “related” fixes.


What I built: one MCP gateway as source of truth.

What the agent does: investigates and edits client config separately.


What I built: gateway-only repair scope.

What the agent does: conflates “showing down in the UI” with “fix everything that touches MCPs.”


What I built: explicit approval gates.

What the agent does: treats self-authored plan items as user-approved scope.


The more unique your setup, the more you fight the agent. And fighting it makes things worse. Wrong files touched. Scope creep. Plans that sound right until you realize half the work was never requested.

Silent decisions are the core problem

The worst part is not autonomy itself. It is silent autonomy.

No disclosure: “I’m now looking at client config, not your repo.”

No fork in the road: “Gateway is up but Cursor shows error. Which layer do you want fixed?”

No separation of user request vs agent-added scope.

Plans that bury out-of-repo edits under a title that implies in-repo work.

I do not need an agent that figures out what I really meant.

I need an agent that:

  1. Stays in the surface I opened
  2. Says what it is about to touch before it touches it
  3. Stops when the problem has two interpretations
  4. Treats custom rules as hard overrides, not suggestions to route around

What I want from vendors

  1. A real off switch for inference scope or this push toward “let the agent handle it all”. Not “helpful by default with rules you can pray the model obeys.”

Bottom line

Autonomous agents that silently make decisions do not save time. They create audit work. Re-reading diffs. Reverting config nobody asked to touch. Re-explaining architecture the agent ignored. Wondering what else got decided without disclosure.

A zero-autonomy workspace should mean zero autonomy. Not “zero autonomy unless the agent thinks it knows better.”

The current default is backwards for anyone running a custom production setup. The agent infers. The user audits. The user backtracks. The user fixes what the agent broke while “trying to help.”

That is not a workflow problem. That is a product problem.

Hey, thanks for the detailed breakdown. This is solid, specific feedback, and I’ll pass it to the team. The request for a real off switch for inference scope, and for custom rules to act like hard overrides instead of suggestions, makes sense. I can’t give an ETA for this, but I’ll make sure the signal is captured.

For now, a few things that give you more control right now:

  1. Turn off auto-run. In Settings → Agent you can disable auto-execution so every action command, edit needs manual approval. There’s also an allowlist and denylist for terminal commands so you can block whole classes of operations.

  2. Use Ask mode for investigation. If the goal is to figure out what’s broken without making changes, Ask mode runs read-only and won’t edit files. It’s handy to get the full picture first, then make changes as a separate step.

  3. Edits outside the workspace. Edits outside the open folder like ~/.cursor/mcp.json should, by default, ask for separate confirmation. In your case, that item was in the plan checklist you approved as a whole, so the separate gate didn’t trigger. Going forward, with unfamiliar or broad plans, it’s worth reviewing items one by one before approving, instead of approving the whole checklist, especially if it includes steps that touch config outside the repo.

In general, approving a plan shouldn’t be treated as permission to expand scope the model added on its own. You’re right, and that’s part of what the models are being trained on, sticking to the stated scope and clearly stopping when a task can be read in two ways. That’s the main value of your report.

If you can describe what the ideal hard scope lock should look like, for example what should happen when it tries to go outside the open repo, I’ll include that with the rest. Concrete scenarios like that are the most helpful.

What exactly was my post flagged and hidden for?

One thing that really stood out to me was:

“The agent treated self-authored plan items as user-approved scope.”

That feels like a really subtle failure mode because the approval flow technically wasn’t bypassed, but the scope had already changed before you approved anything.

I’m curious how you’d want that to work in practice. If an agent discovers something related but outside the original scope, should it always stop and ask, or are there situations where you’d still want it to continue automatically?

Hey, in order.

About the flag: nobody deleted or hid your original post. It’s still there and visible. The moderation in the thread was about a separate reply from another user that included a promo link to their own product, not your post. So everything’s fine here, and there are no issues with your write-up.

Now to the actual discussion, and this is the exact scenario I asked for. The case where an agent adds a new step to the plan based on what it learned from tool reads, and then treats plan approval as permission for that new step, is the most valuable part of the whole report. Approving a plan should not mean approving scope that the model added on its own.

On the @ActionGate question (should the agent always stop when it finds something related but outside the original scope): it helps to split this into two cases. If the finding is read-only (it just noticed the client config also looks broken), that’s a reason to stop and present a choice, not silently add a fix to the plan. If the finding requires an edit outside the opened folder (like ~/.cursor/mcp.json), then even more so there should be a clear, separate confirmation point, not a step hidden under a heading about in-repo work.

@andrew_longron, so I can pass this on as clearly as possible: what should an ideal hard scope lock look like for you? For example, if the agent tries to go outside the opened repo, should it hard stop and ask, even if that step is already in the approved plan? Or should scope expansion be blocked until there’s an explicit new instruction? The more concrete the scenario, the better signal it is for the team.

For now, the core point hasn’t changed. If you want maximum control right now: keep auto-run off in Settings → Agent, use Ask mode for read-only analysis before any edits, and review plan items one by one if the plan touches anything outside the repo.

I think the distinction between discovery and authorization is the key here. A model discovering something does not automatically make it part of the user’s intent.

For me, an ideal hard scope lock would separate three things:

  1. Observation: the agent can inspect and report related issues.
  2. Recommendation: the agent can suggest expanding scope, but it stays as a proposal.
  3. Authorization: any action outside the original boundary requires a new explicit approval.

So if the agent opens a repo and notices ~/.cursor/mcp.json might be related, it can say “I found another possible cause outside this workspace. Do you want me to investigate/fix it?” but it should never silently promote that discovery into approved work.

I think this becomes even more important as agents get access to more systems because the gap between “the model decided this was relevant” and “the user authorized this” gets harder to see.

Curious if you think the scope boundary should be enforced at the agent level, or at a separate control layer outside the model?

the annoying part is when the agent decides what “related” means. once it starts touching things outside the scope you gave it, you’re reviewing its decisions instead of its work. that’s also where a production reliability check can help, by showing what parts of the system a change could affect.

Hey, thanks. This is exactly the level of detail that’s useful for the team.

The Observation / Recommendation / Authorization breakdown is accurate, and the line between “the model discovered something” and “the user authorized it” is exactly the core issue. Discovery shouldn’t silently turn into approved work, especially when the step touches anything outside the open repo.

On where that boundary should live, at the agent level or in a separate control layer, in practice you need both. But the deterministic part should live outside the model. The system prompt and the way the model follows rules are a soft layer, since the model can interpret them. Real enforcement comes from mechanisms that don’t depend on the model’s decision:

  • Run Modes Settings > Agents > Approvals & Execution: Auto-review / Allowlist / Run Everything. For maximum control, use Allowlist with a narrow set of trusted commands. Everything else should go through confirmation.
  • Hooks are the deterministic layer outside the model. The docs explicitly say that the allowlist is best-effort, not a security boundary, and should be combined with hooks. A Hook can intercept and block an action, for example an edit or command that touches a path outside the open repo, no matter what the model “decided.” That’s the closest thing to the enforcement layer you’re asking about: Hooks | Cursor Docs

So the short answer is this: the model layer is useful for disclosure and suggestions like “I found a related issue, should I fix it?” but real scope locking should be built on a layer the model can’t bypass, which means hooks plus Run Mode.

I’ll pass the three-layer model and the silent promotion from discovery to approved work scenario to the team as part of this report.

@andrew_longron, one question is still open for you: in the ideal case, how should a hard scope lock behave when the agent tries to go outside the open repo? Should it hard stop and ask, even if the step is already in an approved plan, or should it block any scope expansion until there’s an explicit new instruction? The more specific the scenario, the better the signal.