You Probably Don't Need an AI Agent

A friend of mine recently spent two weeks building an "AI agent" that reads CSV files from a folder, validates them, and moves them to another folder. He was proud of it. It used Claude, had a retry loop, cost about $0.15 per run, and took 8 seconds to process each file.

I rewrote it in 10 lines of Python. No LLM. Runs in milliseconds. Never fails.

This isn't a knock on him. The problem is that right now, everyone's so excited about LLMs and agents that we've lost track of when to actually use them. Every startup says they're building "AI agents." Half the time it's a script with a ChatGPT call in the middle.

So let's clear this up.

Most of your work is just regular automation

Think about what most software does. It takes an input, follows some rules, and produces an output. That's it. A deploy pipeline, a backup script, a billing job that runs every night. None of this needs AI.

for file in Path("inbox").glob("*.csv"):
    validate(file)
    transform(file)
    shutil.move(file, "processed" / file.name)

This is boring. It's also fast, free, predictable, and easy to fix when something goes wrong. You can write a test for it. You can read the logs and know exactly what happened.

If your task has clear inputs and clear rules, just write code. You don't need an LLM. You don't need an agent. You need a function.

So when do you actually need an LLM?

Here's a real example. You're building a support system and tickets come in as free-text emails. Some are billing issues, some are bugs, some are feature requests. A customer might write "I got charged twice last month" or "your checkout page is broken on Safari" or "would be cool if you had dark mode."

Try writing if-else logic for that. You can't. The inputs are messy, unpredictable, and infinite in variety. This is where an LLM earns its keep.

def categorize_ticket(text: str) -> str:
    response = llm.chat(messages=[{
        "role": "user",
        "content": f"Categorize this ticket as billing, "
                   f"technical, or feature-request: {text}"
    }])
    return response.content.strip()

Notice what's happening here. You still have a pipeline. Tickets come in, get categorized, get routed to the right team. That flow is regular code. The LLM is just handling one step that needs language understanding.

This is what most "AI automation" actually is, or should be. A normal workflow with an LLM plugged in where you need it to understand something fuzzy. Classification, summarization, extraction, translation. Stuff that used to need a whole NLP team.

The rest of the pipeline stays deterministic. You're still in control.

Then what's an actual AI agent?

Imagine asking someone: "Figure out who our main competitors are, compare their pricing to ours, and write up a summary."

You're not giving them steps. You're giving them a goal. They have to figure out how to get there. Maybe they Google some companies, visit their pricing pages, check a few review sites, cross-reference with your own pricing, and then write something up. If one website is down, they try another. If they find something unexpected, they dig deeper.

That's what an agent does. You give it a goal and some tools, and it plans its own steps.

agent = Agent(
    model="claude-sonnet-4-5-20250514",
    tools=[web_search, read_url, write_file],
    instructions="You are a market research analyst."
)

result = agent.run("Analyze the competitive landscape for Vercel")

You didn't tell it to search the web, or which pages to read, or what to compare. It figured that out. That's the difference. An agent has autonomy. It makes decisions about what to do next based on what it's learned so far.

This is genuinely useful for open-ended work. Research, investigation, complex debugging, anything where you can't map out the steps ahead of time because you don't know what you'll find.

But it's also slow (30+ seconds for a multi-step task), expensive (dollars, not cents), and hard to debug. When an agent goes off track, tracing what went wrong through a 15-step reasoning chain is not fun.

The simple test

When you're building something, ask yourself:

Do I know the steps? If yes, write regular code. No LLM needed.

Do I know the steps, but one of them needs to understand language? Plug in an LLM call for that one step. Keep everything else as normal code.

Do I not know the steps because the task is genuinely open-ended? Now you might need an agent.

That's it. Most things fall into the first two buckets. Agents are for the rare cases where you truly can't predict what needs to happen next.

How they work together

The best systems use all three. Here's a real pattern:

A cron job runs every hour and pulls new support tickets (regular automation). Each ticket gets categorized by an LLM (LLM automation). Most tickets get routed automatically. But when the LLM flags something as "potential security issue," an agent spins up to investigate: it checks the user's recent activity, reviews related tickets, searches the codebase for the mentioned endpoint, and writes up a brief for the security team (AI agent).

The cron job is free and instant. The LLM call costs a fraction of a cent and takes a second. The agent costs a dollar and takes a minute. Each one does what it's good at, and nothing more.

Don't use an agent to move CSV files. Don't use a script to understand customer emails. Match the tool to the problem, and you'll build something that actually works.