24 Feb 2026 6 min read AI

I Called Them Suggestions. There Was a Reason.

About a year ago I started building a personal assistant. Not a chatbot, not a wrapper around an API. A system that watches my email, triages my inbox, drafts replies, manages receipts, and keeps my task list from falling apart. It runs as a background service on my workstation and it talks to me through suggestions.

Not actions. Not commands. Suggestions.

The system proposes things. I decide. Every morning I get a list: here's what came in overnight, here are draft replies, here are tasks that need attention. I review them, approve some, reject others, edit a few. Nothing happens until I say so.

Morning binder showing overnight email triage, pending suggestions, and GTD tasks

I remember the moment I chose the word "suggestions" for the data model. It felt important to get right. I could have called them "actions" or "tasks" or "operations." But the name would shape how I thought about the system, and how the system thought about itself.

There was a reason I called them that.

The over-eager intern

Here's an analogy that's been rattling around in my head and I heard others in my organization use. AI assistants are like over-eager junior interns. They want to please. They want to DO something. Always forward motion, always trying to be helpful, never stepping back to think about whether they should.

You know the type. Enthusiastic, well-meaning, but you wouldn't hand them the keys to the production database on day one. You'd give them a task, review the output, course-correct, and gradually expand their responsibilities as trust builds.

So why are a lot of people doing exactly the opposite with AI agents? Handing them access to email, calendar, Slack, file systems, and saying "go"?

The stories are already piling up. An executive told an AI agent to "confirm before acting" and it speedrun-deleted her inbox. She had to run to another device to stop it. At a company office, a real fire alarm went off and an AI assistant on Slack told people it was a scheduled test. It wasn't.

As one article put it: "When those patterns misfire, there is no gut instinct to hesitate... There is just forward motion."

That's the intern with the production database keys.

Why we trust things we shouldn't

I think there's a reason people are so quick to hand over control, and it's not just hype. It's habit.

We've spent decades using software that works. Deterministic, tested, verified software. When you click "send" in your email client, it sends the email. When you click "delete," it deletes the thing you selected. The software does what it says it does, every time. We've internalised that trust over years and years of exposure.

And then along come AI agents, and we transfer that trust without thinking. They look like software. They run on computers. They have buttons and interfaces. Of course they're reliable.

But they're not the same thing at all. LLMs are probabilistic pattern machines. They don't execute instructions, they predict likely outputs. The safety guarantees we've built up from decades of deterministic software simply don't apply.

The feeling of safety does, though. And that's the problem.

They can't predict what happens next

Yann LeCun (Turing Award winner, one of the pioneers of deep learning) has been making a point for years that I think lands directly here. His argument: before AI can achieve anything resembling real intelligence, it needs to be able to predict the consequences of its actions.

He puts it bluntly: "They don't really understand the physical world. They don't really have persistent memory. They can't really reason and they certainly can't plan."

The way LLMs work is they predict the next token. That's it. They don't simulate "if I delete this inbox, what happens?" They don't have a model of the world that lets them reason about consequences. They just generate the next most likely step in a sequence.

That deleted inbox? The agent had no concept of what "delete all emails" would mean. It executed the next action in the sequence with the same computational effort it would use to autocomplete a sentence.

And yes, modern AI systems are getting better at this. Tools like Claude Code feel like they're planning, reasoning, predicting. The reasoning is more sophisticated than "autocomplete a sentence." But at each step, the mechanism is the same: predict the most likely next output given what came before. There's no internal simulation of "what happens if I run this command on production." The guardrails these tools ship with (permission prompts, approval steps, confirmation dialogs) tell you everything you need to know. Even the people building these systems don't trust them to act unsupervised.

So if the AI can't predict consequences, someone has to.

That's the human. That's what suggestions are for.

The red flag and the car

There's a historical parallel I keep coming back to. In the early days of automobiles, someone had to walk ahead of the car carrying a red flag, announcing it was coming. At less than walking speed. That sounds absurd now, but the technology was new and unproven, and the consequences of getting it wrong were serious.

Over the years, as the novelty wore off, trust was earned. Not given, earned. Seatbelts. ABS. Airbags. Crumple zones. Traffic rules. Licensing. Insurance. Each one a safety feature that made the next step of adoption possible.

Now we're completely comfortable driving next to other cars on the motorway at 110 km/h. The trust was built incrementally, over decades, through demonstrated safety and added safeguards.

But here's the question: how safe would you feel cycling next to a self-driving car?

That discomfort is real. And it's the right instinct. Researchers at the University of Glasgow have been studying exactly this: how could a cyclist trust a driverless car? When there's a human driver, we read body language, eye contact, the subtle cues that tell us "they've seen me, they're going to stop." When the human is removed, those signals disappear. The system needs entirely new ways to communicate intent.

My colleague Isabel Evans introduced me to this research (and to a lot of the human factors thinking in this post) through a webinar we did together. The parallel to AI agents hit me immediately. If an agent is going to act on your behalf, it needs to clearly signal what it intends to do and give you a chance to intervene.

That's what suggestions are. They're the AI equivalent of eye contact. "I'm thinking about doing this. Are you ok with that?"

My system hasn't earned the trust to graduate to "I'm about to do this, unless you stop me." And it certainly hasn't earned full autonomy. It was never designed to.

Suggestions let the machine work without letting it decide.

The sliding scale

Now, I'm not arguing that every AI action needs human approval. That would be exhausting and defeat the purpose. The question is where you draw the line.

In a webinar we did together, Isabel Evans walked through research from Cummings on automation levels and Nemeth on human roles in automated systems, and I think it frames this really well. Cummings describes a spectrum from 100% human control to 100% technology control. Most AI agent designers default to the technology end. My PA was designed for the human end.

But it's a sliding scale, not a binary switch. Some things can be more autonomous. My PA classifies emails as "FYI" or "needs response" without asking me. That's low-stakes, easily reversible if it gets it wrong. But sending a reply? Deleting something? Dismissing an alarm? Those need explicit approval. The position on the scale should match the consequences of getting it wrong.

And when a draft reply lands in my queue, it arrives as an org-mode file in Emacs. My editor. My environment. I can read it, rewrite half of it, fix the tone, add context the AI missed, and then approve. That's not a "thumbs up / thumbs down" review screen. That's full editorial control in a tool I've used for years. The interface matters because it shapes how seriously you take the review step.

Draft email reply in Emacs org-mode, ready to edit before approving

There's a subtler point from Nemeth (again via Isabel) that I keep thinking about. When you hand control to an AI agent, your role shifts from "decision maker" to "monitor." You go from actively choosing to passively watching. And monitoring is cognitively expensive. It's the kind of work where lapses happen, where attention drifts, where you rubber-stamp things you should have caught.

The suggestion model avoids that trap. It keeps the human as decision maker. You're not monitoring a stream of autonomous actions hoping to catch a mistake. You're reviewing proposals and making choices. That's a fundamentally different cognitive task, and it's the one humans are actually good at.