The tedious 20%: what's actually worth automating in most offices

Most writing about AI agents in the workplace either oversells ("AI will run your entire back office!") or undersells ("it's just a fancier macro"). Neither is true, and neither is useful if you're actually trying to figure out where to spend an afternoon — or a budget.

Here's the more boring, more accurate version, with the actual numbers attached.

The tasks that actually eat the hours

Ask anyone to track a week of their own admin work, and the same handful of tasks show up every time:

• Reading inbound email and deciding what it is — enquiry, invoice, complaint, spam.
• Re-typing the same information into three different systems because they don't talk to each other — a form submission becomes a CRM entry becomes an invoice line.
• Chasing people for approvals, missing details, or "can you resend that signed PDF?" on a loop.
• Writing the same category of email or report every week, from scratch — quotes, scheduling, "here's what happens next".
• Reconciling a spreadsheet against a system of record to catch the handful of rows that don't match.

None of this is difficult. All of it is draining, precisely because it demands just enough attention that you can't fully switch off, but not enough to feel like real work. It's a quiet tax every office pays, week after week — one client I worked with clocked it at roughly five hours a week going into email triage alone.

Why "just template it" never quite works

The instinct is to fix this with a template, a checklist, or a junior hire. All three help a little, and all three hit the same wall: these tasks are repetitive, but they're not identical. There's always a variant — the client who replies out of order, the invoice with a typo in the reference number, the form that's missing one field. A static template handles the 80% that's routine and silently mishandles, or just chokes on, the 20% that isn't.

That gap is exactly where an AI agent earns its keep, and exactly where it doesn't. It's good at absorbing the pattern-matching, repetitive middle — reading the message, filling the form, drafting the routine reply, flagging the mismatch. It's not good at being trusted alone with the edge case, and it shouldn't be treated as if it is.

What actually changes, concretely

The realistic version isn't "the agent does the task." It's: the agent does the recognizable 80%, and hands the ambiguous 20% back to a person, with the boring part already done.

• Email triage. A small model classifies each inbound message and extracts the two or three fields that matter — name, intent, urgency. The result is a sorted inbox with a one-line summary per message instead of forty raw emails.
• Document intake. Scanned PDFs, receipts, supplier invoices — extraction pulls line items and totals, a human glances at anything flagged, the rest flows straight into the books. This only works if the exception path is designed first: anything the model is unsure about goes to a queue, nothing unreviewed touches the accounting.
• First-draft replies. Not auto-send — a draft sitting in the outbox with the right quote numbers and dates already filled in. The owner edits for tone and hits send.

Someone still reviews the invoice — they're just not the one who typed it in three times first. Someone still signs off on the client email — they're just editing a draft instead of writing one from a blank page.

The economics, briefly: a setup like this typically costs a few hundred dollars to build and runs for single-digit dollars a month. Against four to ten hours a week of saved time, that payback period is measured in days — which is more than can be said for most software projects.

Where I'd tell you not to bother

• Customer-facing chatbots, at small scale. The volume rarely justifies it, and a wrong answer to a real customer costs more than the hours saved.
• "Fully autonomous" anything. If a task would embarrass you when it goes wrong in public, it needs a human in the loop. Full stop.
• Judgment calls dressed up as text generation. Chasing a late-paying client is a relationship decision, not something to hand to a draft-writer.

The part nobody budgets for

The parts that go wrong aren't the AI failing to write a sentence. They're the parts nobody plans for up front:

• Access and permissions. An agent that can read and act on real business systems needs real credentials. Who has visibility into what it touched, and when?
• What happens when it's wrong. Not "if" — when. A process with no visible failure mode is one where mistakes compound quietly until someone finds them the hard way.
• Accountability. If it touches a client record, a payment, or an approval, someone senior needs to be able to say exactly why it did what it did — not "the AI decided."

These aren't reasons to avoid automating tedious work. They're reasons to treat it as an engineering problem with real design decisions, not a toggle switched on in a settings menu.

Where to actually start

Not with "digital transformation." With one task — the single most repeated, most rule-based chore in your week, the one you could already write down the steps for without thinking. Automate just that one. Watch where it breaks. Fix the access, the failure handling, and the accountability question for that one case before you touch a second.

That's a week's project, not a quarter's. Do it right and it costs a few hundred dollars to build and pays for itself in days. Do it wrong — buy the demo first and go looking for a problem afterward — and it becomes everyone's least favorite unexplained black box six months from now.