Stop building agents for everything — here's the decision framework that saves you months

I watched a team spend six weeks building an AI agent to format their weekly reports. Six weeks. For something that could have been a 10-line Python script.

The agent worked, eventually. But it was brittle, expensive to run, and needed constant babysitting. The script would have taken two hours and run forever.

Here's the decision framework I wish they'd had:

Rule 1: If you can write the exact steps in advance, don't build an agent. Build a script.

Agents excel at judgment calls, not deterministic processes. Your weekly report follows the same format every time. Your expense categorization needs to handle edge cases and weird vendor names.

One needs a workflow tool. The other needs an agent.

The judgment test: Ask yourself what happens when the process encounters something unexpected. If the answer is "skip it and log an error," you want automation. If the answer is "figure out what to do," you want an agent.

Examples that shouldn't be agents:

• Backing up files on a schedule
• Sending the same email template to a list
• Converting file formats
• Posting to social media on a timer

Examples that should be agents:

• Triaging customer support emails
• Researching leads before sales calls
• Writing personalized follow-up emails
• Debugging production incidents

The difference? The second list requires interpretation, context, and decision-making that changes based on inputs you can't predict.

The autonomy ladder: Even when you do need an agent, start with the minimum viable autonomy:

Level 1: Agent recommends, human executes
Level 2: Agent executes, human approves
Level 3: Agent executes, human reviews
Level 4: Agent executes, reports after
Level 5: Agent executes, silent unless error

Most teams jump straight to Level 4 or 5. Start at Level 1. You'll catch edge cases and build trust before giving the agent real power.

The complexity trap: Agents add operational overhead that scripts don't. They need monitoring, memory management, error handling, and budget controls. They can hallucinate, get confused by context drift, and make expensive API calls.

Scripts fail predictably. Agents fail creatively.

If your process is deterministic enough to write clear requirements, build a script first. You can always wrap an agent around it later for the edge cases.

But if you're dealing with messy, contextual work that requires judgment calls — that's where agents shine. Don't make them do data entry. Make them do the thinking.