BackPerspectives

Agentic AI starts with the boring work

The near‑term value of agents isn’t a flashy demo—it’s taking repetitive ops and back‑office work off people’s plates so you can scale without adding headcount. How to pick first targets, why clean data matters, and where humans decide.

5 min read

The work that quietly runs the company

I like shiny things as much as anyone. I’ve built AI systems long enough to know how good a demo can feel. But the place agents pay for themselves first isn’t on stage—it’s in the back office. It’s the reconciliation that “just happens,” the status updates that no longer need a nudge, the queue that stops needing a human hall monitor. If you’re a founder looking for leverage, start there.

I run a founder‑led company from Kochi. That geography taught me a bias I won’t shake: architecture first, headcount second. When you treat your model and your definitions as the product, you can let agents carry more of the load without turning your business into a science project. The payoff is practical: the team spends more time on judgement, taste, and customers, and less time on glue.

Where to point agents first

The instinct is to pick a glamorous workflow and “AI it.” The better move is to inventory the work your business does that is consistent, observable, and bounded. Agents thrive where outcomes are clear and risk is containable. A simple filter I use:

  • Repeatable, not rare: The task happens daily or hourly and follows a recognizable pattern.
  • Structured enough to be legible: Inputs and outputs can be expressed cleanly—an order state, a ledger entry, a policy condition.
  • Observable by design: The system emits the events and context an agent needs to act without guessing.
  • Reversible when needed: If an action goes wrong, you can see it and roll it back without collateral damage.

If a task meets these, it’s a candidate. Examples across most companies look similar: moving tickets between states when criteria are met, nudging stale approvals, posting reconciled amounts, compiling routine status updates, triaging low‑risk exceptions, closing loops that should not require a meeting. None of this is glamorous. All of it compounds.

Architecture before agents

Agents are not a shortcut around a messy core. If the underlying data model is fragmented, you teach an agent to chase drift. If your definitions are ambiguous, you outsource ambiguity. The order is boring on purpose:

  1. Agree on “truth.” Represent core concepts once in your system and have everything else adapt to that model.
  2. Make behaviors explicit. Turn “someone will check this later” into a condition the platform can see.
  3. Expose clean surfaces. The places agents touch—queues, states, policies—should be stable contracts, not private glue.

When the core is coherent, agents stop being a fragile layer. They become part of how the platform behaves. I’ve written elsewhere about why I treat architecture as the product; this is where that choice pays. You scale without hiring people to hold together what code could have held together.

Keep judgement with people

There’s a dividing line I won’t cross: machines propose; people decide under uncertainty. Good agents carry the routine and escalate the rest—quickly, with full context. That means two things:

  • Clear thresholds for autonomy: Write down the conditions under which an agent can act without a person (and the ones where it must ask).
  • Fast human lanes: When a decision needs taste or risk trade‑offs, a person steps in with the state visible—what changed, what options exist, and what policy applies.

This isn’t a philosophical stance; it’s operational safety. The goal is to keep humans accountable for judgement while shrinking the surface area that ever needs judgement.

A simple rollout pattern that works

The most successful implementations I’ve seen follow an unglamorous sequence:

  1. Pick one flow you already instrument—say, a handoff between operations and finance that generates too many follow‑ups.
  2. Define “done” precisely. What does good look like? Which fields must match? What time window is acceptable?
  3. Let an agent observe and propose. Have it draft the change it would make, with a reason and a link to evidence.
  4. Move from propose‑only to safe actions. Start with the lowest‑risk updates: tagging, assigning, setting a status, posting a summary.
  5. Expand the boundary deliberately. As confidence grows, allow the agent to take slightly more consequential actions within policy—always with a clean trail and an easy way back.

You’ll notice what’s missing: a promise of “set it and forget it.” The point is not to replace teams. It’s to let the system do the work the system should do, so people can do the work only people should do.

What changes when the boring work disappears

Three things happen quickly when you take this path:

  • More capacity without more seats: The same team handles more volume because routine work no longer competes with judgement.
  • Fewer meetings about drift: When reconciliation and status live in the system, you don’t need recurring check‑ins to push information across a gap.
  • Faster learning: The product improves because routine friction shows up as data, not folklore. You fix classes of problems instead of stories of problems.

I’ve seen small teams punch far above their headcount this way. It feels quiet, then it feels fast.

Avoid two easy traps

Two failure modes show up often:

  • Demo‑driven scoping: Designing from a wow‑moment instead of a real workload. You impress the room and inherit a pet. Start with the spreadsheet column nobody wants to update.
  • Agent before ownership: Asking an agent to reconcile definitions your team hasn’t settled. If two systems disagree on “what a booking is,” an agent won’t fix that. Decide first.

If you skip these traps, the rest is unremarkable—in the best way. The business gets calmer. Exceptions become obvious. People have more time for judgement and customers.

The other side of “trust”

In a recent piece I wrote about the customer side of agents—why, when AI books the trip, trust becomes the product. This essay is the inside view: trust also looks like a business that closes loops without asking people to carry water between tools. If you want that outside‑in perspective, read: When AI books the trip, trust is the product.

If you’re new here and want context on me and what I’m building, the About page has more.

Closing

Agentic AI starts paying real dividends when it makes the boring work disappear. Start with repetitive, observable, low‑risk flows. Insist on a clean model before you automate. Keep judgement with people. You’ll feel it first in the calendar, then in the ledger.

Get in touch →

Continue the conversation
Have a travel systems problem like this? I’d love to help.