THE METHOD

The Tool We Recommended, Then Quietly Stopped Using

2026-09-20

When we first tested Manus for the directory, it did what the pitch promised: handed it an open-ended, multi-step task, and it planned and executed the whole thing without hand-holding. It earned its spot in the automation category on the strength of that test, with an honest take already flagging that autonomous agents fail in harder-to-catch ways than a single chat answer.

Then we actually started relying on it for a real recurring task instead of a one-off demo. The first few runs looked fine. A few weeks in, one run quietly built a recommendation on top of an assumption that wasn't true, buried a few steps into its own reasoning where it never got surfaced back to us. Nothing crashed. Nothing errored. The output just looked confident and was wrong in a way that took real effort to catch.

That's the specific failure mode with agentic tools that doesn't show up in a quick test: the errors compound quietly instead of announcing themselves. A single bad answer from a chat assistant is easy to spot and easy to ignore. A multi-step plan built on one wrong turn near the start looks polished the whole way through, which means catching it requires reviewing the work almost as carefully as if you'd done it yourself.

There's a useful comparison here to how enterprise software vendors used to talk about integration risk before AI existed. A single point-to-point system failing loudly is annoying but cheap to diagnose, because the failure is obvious and localized. A chain of automated handoffs failing silently somewhere in the middle is expensive precisely because nothing tells you it happened; you only find out when the downstream output looks wrong, and by then you have to work backward through every step to find where it broke. Agentic AI tools have exactly that shape, just compressed into minutes instead of days.

We didn't pull the listing. It's still a genuinely capable tool and the honest take already warned about exactly this. What changed is how we personally use it: not as a default hand-it-off-and-walk-away tool anymore, but as something we still check closely, which quietly erases a lot of the time savings that made it appealing in the first place.

That last point deserves more weight than we initially gave it. The value proposition of a fully autonomous tool depends entirely on being able to trust the output without checking it, because the moment you're checking every run, you've reintroduced most of the labor the tool was supposed to remove. A 90% time reduction sounds impressive until you realize you still have to review the other 10% closely enough that it eats most of the saved time back.

The broader rule this confirms, one we've said elsewhere on this site: an automation only earns a permanent place if you can trust the output without redoing the review work yourself. A tool that's impressive in a demo and merely fine in daily use isn't a failure exactly. It's just not the thing the demo made it look like.

If you're evaluating a similar tool right now, don't judge it on the first successful run, and don't judge it on the tenth either. Judge it on whether the effort required to verify its output ever drops meaningfully below the effort of doing the task yourself. For us, with this specific tool, on this specific kind of task, it never quite did.

It's worth adding that this isn't a knock on Manus specifically so much as a knock on the entire current generation of fully autonomous agents. Every tool in that category we've tested shares some version of this same silent-compounding-error problem, because it's a structural property of chaining multiple AI decisions together without a human checkpoint in between, not a bug specific to one vendor's implementation.