Stop Reaching for an AI Agent When a Cron Job Would Do

Everyone wants an AI agent now. It's the shiny thing. But half the workflows I get asked to "agentify" would run cheaper, faster, and more reliably as a deterministic pipeline you could have written in 2015.

The real skill in 2026 isn't building agents. It's knowing when not to.

Let's draw the line clearly.

The core difference: decision-making, not intelligence

Traditional automation follows a fixed path. Trigger → step → step → done. If the input matches the shape you designed for, it works every time. If it doesn't, it breaks predictably.

// Traditional automation: deterministic, cheap, boring, reliable
async function onNewInvoice(invoice) {
  if (invoice.amount > 10000) {
    await slack.notify('#finance', `Large invoice: ${invoice.id}`);
  }
  await sheets.append('invoices', invoice);
  await accounting.sync(invoice);
}

You know exactly what this does. You can unit test it. It costs nothing to run and it never hallucinates a vendor name.

An AI agent is different. It's given a goal, a set of tools, and the freedom to decide the steps. It reasons about what to do next based on context it wasn't explicitly programmed for.

# AI agent: reasons, chooses tools, handles ambiguity
agent = Agent(
    goal="Resolve the customer's billing dispute",
    tools=[lookup_account, issue_refund, escalate_to_human, send_email],
    guardrails={"max_refund": 200, "require_approval_above": 200},
)

result = agent.run(ticket="I was charged twice and I'm furious")

The agent might look up the account, spot the duplicate charge, issue a refund, and write an apology email — or decide it's over its refund limit and escalate. You didn't script that branching. It chose.

That flexibility is the feature. It's also the liability.

When traditional automation wins

Reach for a plain workflow when:

• The path is knowable. If you can draw the flowchart, you don't need reasoning. You need a trigger and some steps.
• The inputs are structured. Webhooks, form submissions, database rows, API payloads. Clean data going into clean logic.
• Errors are expensive. Payments, provisioning, compliance. You want deterministic behaviour you can audit line by line.
• Volume is high and margins are thin. An LLM call per row gets pricey fast. A function call does not.

Most "AI automation" projects I see in operations teams are actually this. Route the lead, enrich the record, sync the systems, fire the notification. No intelligence required — just plumbing done well.

When AI agents earn their keep

Bring in an agent when the problem has one of these traits:

Unstructured input

Inbound emails, support tickets, PDFs, meeting transcripts. When the shape of the input varies wildly, hard-coded parsing collapses. An LLM extracting intent and entities from a messy email is genuinely better than a hundred regex rules.

Branching you can't fully enumerate

A customer message could be a refund request, a feature question, a complaint, or all three. Writing every branch is a losing game. Let the model classify and route, then hand off to deterministic steps for the actual work.

Multi-step reasoning over tools

Research tasks are the sweet spot. "Find this company's recent funding, summarise their tech stack, draft a personalised outreach angle." That's search → read → synthesise → write, with the sequence depending on what's found along the way.

The pattern that actually works: agents and automation

The best systems aren't one or the other. They're deterministic pipelines with a thin layer of intelligence at the ambiguous points.

Use the agent for the fuzzy decision, then drop into rigid, testable code for the execution.

# Agent decides. Deterministic code executes.
category = classifier_agent.run(email.body)  # fuzzy → structured

if category == "refund":
    process_refund(email)      # plain function, fully tested
elif category == "bug_report":
    create_ticket(email)       # plain function
else:
    route_to_human(email)      # safe default

The agent does what only an agent can — turn mess into a clean signal. Everything downstream stays boring, auditable, and cheap.

A quick decision test

Before you build, ask three questions:

1. Can I write the flowchart? If yes → automation.
2. Is the input structured? If yes → automation.
3. Does the next step depend on interpreting meaning? If yes → agent, scoped tightly.

If you answered "agent" to number three, still wrap it in guardrails: spending limits, approval gates, human-in-the-loop for anything irreversible.

The strategy that saves money in 2026

Start with the cheapest tool that solves the problem. Deterministic first. Add intelligence only where determinism genuinely fails.

Teams that lead with agents burn budget on token costs, debug non-reproducible failures, and end up bolting on the exact validation logic they could have started with.

Teams that lead with clean automation, then surgically insert agents at the ambiguous joints, ship faster and sleep better.

The agent isn't the goal. The outcome is. Pick the dumbest tool that gets you there — and reserve the smart one for the problems that actually need a brain.

---

Originally published at getmichaelai.com