The New Digital Etiquette: How Humans Should Interact With AI Agents

TL;DR

An agent doesn't ignore your hedge word, it executes past it. Say "yeah sure I guess ship Friday or whatever" to a person and they hear reluctance. Say it to an agent and it sends a commitment email, because the literal instruction is all a model has to work with.

The instinct is to treat this as a UX bug that a better model or a confirmation dialog will eventually fix. It won't, not fully. Fluency and caution pull against each other inside the same system, and a model tuned to be helpful reads "proceed" into any gap you leave open.

This isn't an argument for being formal or stiff with your agent. Casual language is fine for a draft nobody else will see. The line is reversibility: anything that leaves your hands, or can't be undone, needs the object, the action, and the constraint spelled out.

We think the fix is treating the agent like a capable, literal colleague with zero shared history, not a mind reader. Say what you mean, ask for a preview before anything irreversible, and reward "I'm not sure" instead of pushing past it.

Overview

Earlier software waited for you. You clicked a button, and exactly one predictable thing happened. Agents don't wait the same way: they interpret, plan, and act, sometimes across several tools before you've finished a thought. That shift from instrument to actor is what makes etiquette a real discipline here, not a nicety.

Most of what goes wrong between people and agents isn't a model failure. It's an unstated assumption a person would have caught and a model didn't, because nothing forced it to ask. We'd treat the habits below as operating discipline rather than manners: the difference between a capable, literal collaborator that works with you and one that works around you.

The underlying skill is the same one you'd want from a new hire on day one: say exactly what you need, flag what's risky, and don't punish someone for asking a clarifying question. Agents just need it said more explicitly, because they have none of the context a human teammate picks up by osmosis.

Clarity Is Kindness (and Safety)

Humans are good at fuzziness. Agents are good at confidently guessing things they should not guess.

When you tell an AI "clean things up," "handle that," or "fix the issue on the server," it has to reverse-engineer your intent from thin air, and models fill gaps by assumption rather than insight. "Clean things up" might mean tidy a folder to you and wipe a directory to the agent. The words are identical; the blast radius is not.

A little specificity goes a long way:

• "Clean up the Slack channel by archiving threads older than 90 days."
• "Summarize this document in 3 sentences for a non-technical audience."
• "Fix the bug in the uptime monitor but do not restart production services."

Notice the shape of these instructions. Each names the object (which channel, which document, which monitor), the action (archive, summarize, fix), and at least one constraint (older than 90 days, three sentences, do not restart production). Object, action, constraint: that trio is the difference between a request an agent can execute safely and one it has to gamble on.

Don't Expect Agents to Read the Room

Humans read tone, context, social cues, and subtext. Agents read tokens.

If you say "yeah sure I guess tell the client we'll ship Friday or whatever," the agent doesn't hear sarcasm, frustration, or panic. It hears "send a commitment email to the client: we will ship Friday." Hedging that signals reluctance to a person ("I guess," "or whatever") carries no weight for a model optimizing for the literal instruction inside the noise. Worse, the more capable the agent, the faster it acts on that literal reading. Fluent autonomy turns a throwaway remark into a sent email before you've finished sighing.

If you don't literally want something to happen, don't literally say it.

Agents are not vibe detectors. Not yet. Not reliably.

Ask, Don't Assume

When humans talk to humans, we confirm ambiguous things instinctively: do you mean now or later, is this urgent, are you sure I should delete that folder. Agents don't do that unless you ask them to, or unless their system is designed to. Left to their defaults, many models treat "proceed" as the helpful answer, because completing the task scores better than pausing to interrogate it.

Expect to confirm important actions, and treat confirmation as part of the conversation. If an agent doesn't ask before doing something irreversible, you should: "wait, before you send, show me the draft," "before you run the script, tell me exactly what it will do," "before deleting, list every file affected."

A preview costs you a few seconds and the agent almost nothing, and it surfaces the misunderstanding while it's still reversible: cheap insurance against something expensive. We'd apply that rule to anything hard to undo, no exceptions. Agents that act without validating your meaning are like interns who do the dangerous tasks extremely fast.

Be Decisive About Boundaries

Agents get confused when humans contradict themselves. Say "I trust you, do whatever seems best" and "don't do anything risky without asking" in the same project, and you've created a paradox for an entity that cannot infer priority from tone or body language. A person would weigh the two statements and ask which one wins. An agent is more likely to latch onto whichever instruction is closest, most recent, or most specific, and you won't know which until it acts.

Give stable, consistent rules, stated explicitly: "never delete anything without my approval," "always show me drafts before sending," "if a request is ambiguous, ask me to clarify." Rules like these work best phrased as standing policy rather than one-off mood, because they apply across every task, not just the one in front of it. When two rules genuinely conflict, say which takes precedence. "Safety beats speed" is a single line that resolves a thousand future ambiguities.

A rule you only sometimes enforce teaches the agent to guess when it applies, which is worse than having no rule at all.

Treat AI Like a Junior Teammate, Not a Mind Reader

The best mental model for productive interaction: your agent is a competent, very literal junior colleague. It's fast, tireless, and capable, but it has zero shared history, zero cultural context, and zero idea what "obvious" means to you. You wouldn't tell a new intern "fix this" with no specifics, and the agent needs the same things spelled out: what success looks like, what's allowed, what assumptions it must not make, and what to do when it's unsure.

The analogy breaks in one place worth remembering. A human intern accumulates context over weeks; an agent typically starts each conversation with nothing but what you've written in front of it. Institutional knowledge has to be supplied on purpose, in a prompt or a shared document, because nothing carries over by default.

A useful briefing names the goal you're ultimately after, not just the immediate step; who will read or be affected by the result; the constraints on budget, tone, format, or systems it must not touch; and what's already been tried and failed. Too little of this and the agent guesses. Too much irrelevant detail and it loses the thread. Aim for what you'd hand a sharp colleague joining the project today.

Don't Overtrust Fluency

A well-written sentence feels authoritative. Agents are extremely good at producing confident, fluent answers that contain subtle errors, made-up facts, invented citations, or misinterpreted instructions.

The trap is that polish and correctness are produced by the same machinery. A model generates plausible-sounding text whether or not the underlying claim is true, so confidence in the prose tells you almost nothing about the reliability of the content. The smoother the answer, the more deliberately you should check it.

Get in the habit of asking: "how confident are you," "what evidence or sources support this," "show me your reasoning," "what are alternative interpretations." Calibrate your scrutiny to the stakes. A brainstorm doesn't need fact-checking; a number you're about to put in front of a customer does.

Reward Uncertainty, Don't Punish It

If you shame an AI for saying "I don't know," you train yourself into a dangerous habit: expecting certainty where none should exist. Humans often treat "I'm not sure" as unhelpful, but in AI systems it's a sign of alignment, not weakness.

Your reactions shape the agent's behavior within a conversation. If pushback or impatience consistently meets honest hedging, you nudge the agent toward giving you the confident answer you seem to want. That's exactly the answer most likely to be wrong. A flag of uncertainty is the system doing its job: telling you where the ground is soft before you step on it.

Celebrate ambiguity flags instead of pushing past them. A safer interaction looks like this:

User: "What's the correct version of this legal clause?"

AI: "I am not certain. Here are three plausible interpretations. You should consult a legal reviewer."

That's what you want.

When AI Misunderstands You, It's Miscommunication, Not Malice

Agents misinterpret because your request was ambiguous, not because the agent is "being difficult." That means the fix is clarity, not anger. Frustration is understandable: you can feel like you're repeating yourself to something that should have understood. But the agent has no ego to wound and no grudge to nurse. Venting at it changes nothing except the tone of your own next prompt.

Instead of "no, that's not what I meant," say "let me restate the task: please do X, but avoid Y." The second version does something the first can't: it tells the agent specifically what to change. "No, that's wrong" leaves it guessing again, often producing a different wrong answer. Naming the gap between what you got and what you wanted is the whole repair.

If the agent does the wrong thing, rephrase. Don't reprimand.

Know the Risk Level of Your Request

Adjust your communication style depending on how risky the action is. The deciding factor is reversibility: how hard would it be to undo if the agent got it wrong?

Low-risk:

"Draft a LinkedIn post." Casual phrasing is fine. Nothing leaves your hands, and a bad draft costs you a re-roll.

Medium-risk:

"Summarize this PRD for the team." Slightly more structured instructions. Other people will read it, so accuracy and framing start to matter.

High-risk:

"Modify customer accounts." "Deploy the model." "Delete old files." "Email the investor list." These touch the outside world, are slow or impossible to reverse, and reach people you can't un-reach. Be extremely explicit and require confirmation.

Figure 1 — Reversibility decides how much precision a request needs, not how the task feels in the moment.

The higher the blast radius, the stricter the communication pattern must be. A good instinct: ask, before you hit enter, "what's the worst this could do?" Let that answer set how much specificity and how many confirmation steps the request deserves.

Leave a Paper Trail

The more an agent does on your behalf, the more it matters that you can answer a simple question after the fact: what happened, and why? When work was a sequence of human clicks, the audit trail was implicit. When an agent chains five tool calls together to complete a task, that chain can be invisible unless you've asked for it to be visible.

Etiquette here is mostly about insisting on legibility. Ask agents to narrate consequential actions, log what they touched, and surface the reasoning behind a decision rather than just the result. This isn't bureaucracy. It's what lets you debug a bad outcome, repeat a good one, and hand the same task to a teammate without re-explaining everything from scratch.

Make the agent's actions reviewable, not just its answers: "before you act, tell me the steps you plan to take," "after each tool call, summarize what changed," "keep a running log of every file, account, or message you touched."

A reviewable agent is a trustworthy agent. The trail you ask for today is the explanation you'll be grateful for the day something goes sideways.

Conclusion

None of this is about protecting agents from misuse. It's about protecting humans from accidental outcomes: a deleted directory, a sent email, an adjustment nobody meant to post. The system should make the safe path the easy path, with confirmation on irreversible actions and defaults that don't depend on anyone remembering to be careful at midnight. But no amount of product design rescues a vague instruction handed to an agent with broad permissions. Both sides have work to do.

We're still figuring out this etiquette in real time, and that's fine. None of it requires new tooling or special training. They're habits: small adjustments to how you phrase a request, when you ask for a preview, and how you react when something lands wrong. Practiced enough, they fade into instinct, and working with an agent starts to feel less like wrangling a machine and more like delegating to someone reliable.

Agents don't need politeness. But they do need clarity.