Our Commitment to Your Agents' Security: Human In The Middle

BotTrottr Team · · Security

A BotTrottr agent can read your inbox, triage your calendar, and pull context from your files without bothering you. That’s the point — those tasks are safe to automate. But the moment an agent wants to act on the outside world — send an email, make a payment, write to an account — that’s a different kind of task, and today we built the system that makes sure it never happens without you.

Why writes are different

Reading is reversible. Sending is not. When an agent reads your calendar, the worst case is it saw something it didn’t need. When an agent sends an email, that message lands in a real person’s inbox, from your address. When an agent makes a payment, real money moves. These actions are irreversible, they reach other people, and they happen in your name.

That’s the whole reason for a human in the loop. An agent should be able to propose any write action — but the actual send, payment, or mutation should only happen after you say yes.

How it works: three layers, one promise

The promise is simple: no write ever reaches the model. Here’s how we enforce it.

Layer 1 — least privilege by consent. When you connect an account (Outlook, Gmail, and so on), we ask for the smallest set of permissions that covers the work. We covered the exact Outlook scopes in our earlier post — the theme is the same everywhere: read what’s needed, and treat write access as the exception.

Layer 2 — the dispatcher gate. Every tool call an agent makes flows through one place. That gate checks each tool: read tools run immediately; write tools never do. A write tool — sending an email, making a payment — is intercepted and turned into a proposal instead of an action. The agent gets back “proposal created, awaiting your approval,” not a sent message.

Layer 3 — the proposal queue and a separate executor. The proposal lands in your approval queue. Only one place in the system can actually perform a write — the executor — and it only runs after you approve, using your own connection. When you approve an email, it’s sent through your Outlook or Gmail account, as you. BotTrottr never sends on your behalf through a platform address.

What you see when an agent tries to act

The flow is short and you’re in control at every step:

  1. Your agent decides it needs to send an email or make a payment.
  2. Instead of acting, it files a proposal describing exactly what it wants to do.
  3. You get a prompt — in the Approvals view of your dashboard, and by email — with Approve and Reject.
  4. Approve, and the executor carries it out through your own connection. Reject, and nothing happens.

Every approval link is signed, single-use, and expires — so an old link can never be replayed later. And every decision is written to an audit trail, so you always have a record of what was proposed, what you decided, and what ran.

Start strict, then turn up the trust

The system ships with the strictest posture: every write action asks. That’s the right default, because an agent’s judgment is something you build trust in over time, not assume on day one.

Once you do trust an agent, you’re not stuck clicking forever. BotTrottr supports the full spectrum of human oversight — in the loop, on the loop, and out of the loop — and you choose the mode per agent, per action. The names come from the safety literature, and the difference between them is where you stand relative to the decision.

Human in the loop

You are at the decision point. The agent proposes; you approve or reject; nothing happens until you do. Every write action stops at your desk.

This is the default on BotTrottr, and the right place to start for anything irreversible: sending mail as you, moving money, deleting data. You see the exact proposal — recipient, amount, content — before it runs, and an approval you don’t give is a write that never happens.

Use it for: payments, outbound email, anything touching a third party, anything you can’t undo.

Human on the loop

You are above the decision point, supervising the system rather than each action. Instead of reviewing every proposal, you define a boundary in advance — narrow, explicit rules about what the agent may do unattended — and you watch the boundary hold. Actions inside your rules run automatically. Everything outside them still comes to you.

If “in the loop” is approving each invoice, “on the loop” is setting the policy: sends to anyone @mycompany.com — go ahead; anything outside the company, ask me. You’re not clicking more, you’re deciding once what deserves a click. This is the mode that makes autonomy workable at scale, because your attention scales with the number of exceptions, not the number of actions.

Two properties make it safe rather than reckless. The rules are narrow — they match on specifics (provider, action type, risk, and fields of the actual proposal payload like {"args.to": {"$contains": "@mycompany.com"}}), not a blanket “this agent is trusted.” And they are auditable and versioned: every rule has a version number, and every time one fires, it’s written to the same audit trail as a human approval. You can always answer “why did that run on its own?” — the rule, and its version, are on the record.

Use it for: high-volume, low-risk actions where the occasional edge case still deserves your eyes. This is where most teams should land.

Human out of the loop

You are outside the decision point entirely. The agent acts on its own; you review after the fact, through the audit trail. This is full autonomy — and on BotTrottr it’s an explicit, deliberate choice, never a default.

It exists because some agents genuinely don’t need you in the path: a monitoring agent restocking a low-stakes resource, a digest agent filing summaries, work where an occasional mistake is cheap and correction is easy. Even here you keep visibility — every auto-approved action is logged, so “out of the loop” means not pre-approving, not not knowing. You stay accountable for the system even when you’re not in the path.

Use it for: reversible, low-blast-radius work you’ve already watched run clean, and only for agents you’ve genuinely come to trust.

Choosing, and changing your mind

All three modes are live in BotTrottr today. Strict is the default — every write asks — because the right way to travel this spectrum is in one direction: start in the loop, graduate to on the loop as you learn which proposals are consistently safe, and reach out of the loop only for work you’ve watched run clean. Trust is earned by evidence, and the audit trail is where you find it.

The best part is that moving is cheap and reversible in both directions. Turning autonomy up is a rule you can write in a minute; turning it down is deleting that rule. If an agent’s behavior starts drifting, drop it back a mode or two and the human gate is there again, exactly as before. You are never locked into a level of trust you’ve outgrown — in either direction.

Approvals are a prompt-writing teacher

Here’s the part we don’t talk about enough: every approval is feedback. If you keep rejecting the same kind of proposal — your agent keeps trying to email cold contacts, or draft payment-sized changes you’d never approve — that’s a signal about your prompt, not just your agent.

Read the approval history as a mirror of your instructions. Notice the pattern, then tighten the prompt: “Never email anyone outside @mycompany.com.” “Always draft, never send, to new contacts.” “Pay only invoices I’ve already marked approved.” A few precise lines in your prompt prevent a dozen approvals — the approval log is how you discover which lines those are. Good agents get better when you teach them, and the approval queue is the fastest way to see exactly what needs teaching.

Our commitment to your agents’ security

Everything above is one expression of a bigger principle: your agents work for you, so they should be accountable to you. Concretely, that means:

  • Least privilege everywhere — connections ask for the minimum, and read access is the default.
  • No write token ever reaches the model — the model can only propose, never perform.
  • A human gate on every write — sends, payments, and mutations wait for you.
  • A full audit trail — every proposal and decision is recorded.
  • Single-use, expiring approval links — a stolen link can’t be replayed.
  • All three oversight modes, your choice per agent — human in the loop by default; narrow auto-approve rules when you want to supervise a boundary; full autonomy only where you deliberately grant it.
  • You can revoke any connection at any time — and access stops immediately.

We’d rather an agent ask one time too many than act one time too few. That’s the trade we’re willing to make on your behalf.


Follow along for more on how BotTrottr keeps your agents safe, useful, and accountable via the RSS feed, and reach out any time with questions about how approvals work with your setup.

← Back to all posts