ProjekinAja. Agentic AI Stage 3 · Working With Agents Lesson 3.11
● Stage 3 · Lesson 3.11

Cost, Speed & When NOT to Use an Agent

The mark of mastery isn't using agents for everything — it's knowing when a simpler tool wins. Agents cost tokens, time, and attention. Spend them wisely.

⏱ ~14 min read ⚖️ Judgment, not hype 🏁 Stage 3 finale

🎯 By the end you'll understand

The three real costs of running an agent (money, time, and attention), the cheaper tools that often beat it, a four-question framework for deciding whether an agent is worth it, the habits that keep agent costs in check, and why reaching for an agent to feel cutting-edge is the most expensive mistake of all.

KEY INSIGHTThe one idea to take away

A great operator doesn't reach for the most powerful tool. They reach for the lightest tool that does the job.

You've spent this whole stage learning to brief, scope, supervise, and trust agents. Here's the twist that turns all of it into real skill: the most advanced answer is often "don't use an agent at all." A one-shot answer, a five-line script, or thirty seconds of your own time will frequently beat a multi-step agent on cost, speed, and reliability.

🔑 Hold onto this

An agent is not free. Every loop turn spends tokens (money), adds latency (time), and demands supervision (your attention). Those costs are invisible until you total them up — and once you do, a lot of "let's use an agent" ideas quietly become "let's just write a script."

CORE CONCEPTThe three real costs of an agent

People talk about agents as if the only question is "can it do the task?" The harder, more useful question is "what does it cost to make it do the task?" There are three bills, and they all come due.

1. Money — tokens. An agent doesn't think once; it loops. And here's the part that surprises everyone: on each turn of the loop, the model re-reads its entire growing context — the goal, every prior step, every tool result so far (you saw exactly why in Lesson 3.3 and Lesson 2.3). A 10-step task isn't 10× the cost of one prompt — it's worse, because each step carries more context than the last. Long runs get expensive in a way that compounds.

2. Time — latency. A chatbot answers in one round trip. An agent makes many: think, call a tool, wait for the tool, read the result, think again. Each tool call and each model turn adds seconds. A task that feels like it should be instant can take a minute or two of watching a spinner. For anything a human is waiting on in real time, that latency is a real cost — sometimes the deciding one.

3. Attention — supervision. Because an agent acts, you can't fully look away. As you learned in Lesson 3.6, reviewing an agent's work, catching its confident mistakes, and approving consequential steps is real human labor. An agent that "saves you 20 minutes" but requires 15 minutes of careful review didn't save you much — and it cost you focus you could have spent elsewhere.

📖 The hidden multiplier

The three costs interact. A long run (money) is also a slow run (time) that produces more output to check (attention). When an agent is the wrong fit, you don't pay one of these — you pay all three at once.

COMPARISONAgent vs the alternatives, by cost

Lay the four common approaches side by side and the trade-offs jump out. There is no "best" row — there's only the best fit for a given task.

Approach💰 Money⏱ Time / latency👁️ AttentionShines when
🙋 Do it yourself$0secondsall of it (but brief)a one-off, 30-second task
💬 One-shot chatbotone prompt's wortha few secondsread one answeryou need an answer, then you act
⚙️ Deterministic script≈ $0 to runmillisecondsnone once trustedfixed steps, runs often
🤖 Agentmany growing turnstens of seconds+review the runvariable steps, high value, hard to script

Notice the pattern: the agent's row is the most expensive on every axis. That's not an argument against agents — it's an argument for using them only when their one superpower (handling variable, judgment-heavy, multi-step work) is actually what the task needs.

PRACTICALThe cheaper tools that often win

Before you spin up an agent, ask whether one of these does the job for a fraction of the cost.

🙋

Just do it yourself

If the whole task is a 30-second action — rename a file, reply "yes," click one button — the cheapest tool is your own hand. Briefing an agent to do it would take longer than doing it.

💬

A one-shot chatbot answer

If you need information or a draft and you'll take the action, a single prompt is faster and cheaper than a loop. "Summarize this," "write me a first draft," "explain this error" — one turn, done. No tools, no supervision, no spinner.

⚙️

A deterministic automation or script

If the steps are fixed and the task repeats, a plain script or automation (the kind you met in Lesson 1.5) wins outright. It's faster, free to run, and — crucially — it does the same thing every time. No model needed to rename 400 files in a folder.

💡 The litmus test

If you can write down the exact steps in advance and they never change, you don't need an agent — you need a script. An agent earns its keep precisely when you can't predict the steps and need something to decide them on the fly.

SEE ITAgent or Not? — a quick recommender

Describe a task with four toggles and this little recommender picks the lightest tool that fits. Try to find a setting where it actually says "Agent — worth it." You'll notice that's harder than it sounds — which is exactly the point.

🧮 Interactive · Pick the lightest tool for the job

Set the four properties of your task, then read the verdict.

Recommendation
—

Illustrative heuristic, not a law — real decisions have more nuance. But notice how often the honest answer is the simpler tool.

FRAMEWORKFour questions before you reach for an agent

The widget runs on four questions. They're worth carrying in your head as a checklist. Run any task idea through them in order:

1

Is it valuable enough to justify the cost?

An agent costs money, time, and attention. If the task is trivial or rarely matters, those costs outweigh the benefit. High value buys an agent permission to be expensive.

2

Is it well-suited to an agent?

Back to the fit test from Lesson 1.6: variable steps, needs judgment, tolerates a little messiness. If the steps are fixed and exact, it's a script's job, not an agent's.

3

Would a simpler tool do?

Could a one-shot prompt answer it? Could a script handle it? Could you just do it? If yes, stop here — you've found the lighter tool.

4

Is the failure cost acceptable?

An agent will sometimes get it wrong. If a confident mistake here is cheap to catch and undo, fine. If it's irreversible or high-stakes and hard to verify, the supervision cost soars — think twice.

▸ The shape of a "yes"

Use an agent when the task is valuable, has variable steps a script can't capture, has no simpler tool that fits, and produces results you can actually check. Miss any one of those and a lighter tool usually wins.

PRACTICALCost-control habits for when you DO use one

Say the four questions came back "yes" and an agent really is the right call. You still don't have to let it run wild. These habits — most of which you've already met in this stage — keep the three bills down.

💡 Cheapest of all

The biggest cost saving isn't a clever setting — it's the run you didn't start because a script would have done it. Cost control begins before the agent does.

WEAKNESSThe over-engineering trap

Here's the failure that catches even smart, experienced people: reaching for an agent because it's impressive, not because it's right. Agents are the exciting new thing, and there's a quiet pull to use one so the solution feels modern and cutting-edge.

Resist it. A multi-step agent that occasionally hallucinates a tool call is a worse solution to "rename these files by date" than a five-line script that does it perfectly, instantly, for free, every time. Choosing the agent there isn't sophistication — it's the opposite. You've added cost, latency, supervision, and a new way to fail, in exchange for a worse outcome.

📖 Over-engineering

Solving a problem with more machinery than it needs. With agents it looks like: using a reasoning loop with tools where a single prompt — or no AI at all — would have been faster, cheaper, and more reliable.

The engineers and operators who truly understand agents are, paradoxically, the ones most willing to not use them. They've felt all three costs firsthand, so they spend them like they're spending their own money — because they are.

WEAKNESSCommon mistakes to avoid

✗ "Use an agent because it's impressive."

Coolness is not a requirement. If a script or a single prompt does the job better and cheaper, that is the advanced answer. Choosing the heavier tool to look modern is over-engineering, not mastery.

✗ "Ignore token cost on long runs."

Because each loop turn re-sends the growing context, a long run costs far more than "number of steps × one prompt." Watch long-running agents like a meter — the bill compounds quietly.

✗ "Run an agent with no step budget."

An uncapped loop can wander, retry, and burn money and time with nothing to stop it. Always set a max-step or token ceiling. A budget isn't a limitation — it's a seatbelt.

KEY INSIGHTWhere this connects in your course

  • Autonomy levels (1.2) — picking the right level is also a cost decision: more autonomy, less supervision, but higher failure cost.
  • Deterministic automation (1.5) — the script that beats an agent whenever the steps are fixed and the task repeats.
  • Task fit (1.6) — the "is this well-suited?" question, now reframed as "is it worth the cost?"
  • Context window (2.3) — why long runs get expensive: each turn re-reads the whole growing context.
  • Step budgets & limits (2.9) — the cap that stops a runaway loop from burning money and time.
  • Lean context (3.3) — fewer tokens per turn means cheaper and more reliable runs.
  • Scoping — Delegation (3.5) — a tight scope is your cheapest cost control; vague goals burn tokens wandering.

This lesson closes Stage 3. You've learned not just how to work with agents — briefing, supervising, trusting, automating — but the senior skill on top of all of it: knowing when not to. The lightest tool that does the job is the right tool.

GLOSSARYKey terms introduced

Token cost
The money an agent spends; rises faster than step count because each loop turn re-reads the whole growing context.
Latency
The time cost — the delay from an agent's many model turns and tool calls versus one-shot's single round trip.
Supervision cost
The human attention spent reviewing, catching mistakes, and approving an agent's actions; real labor, not free.
Over-engineering
Using more machinery than a problem needs — e.g. an agent where a prompt or script would be faster, cheaper, and more reliable.
Step budget
A hard cap on how many steps, tool calls, or tokens an agent may use, to stop runaway loops.
Right tool
The lightest option (DIY, one-shot, script, or agent) that actually does the job — the goal of every cost decision.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1What are the three real costs of running an agent?›

Money (tokens — and they compound, since each loop turn re-sends the growing context), time (latency from many model turns and tool calls), and attention (the supervision of reviewing and approving its work).

2You can write down the exact steps for a repeating task in advance, and they never change. Agent or not?›

Not an agent — a deterministic script. Fixed, repeating steps are a script's job: faster, free to run, and identical every time. Agents earn their keep when the steps are variable and need judgment on the fly.

3Why does a 10-step agent run cost more than 10× a single prompt?›

Because on each loop turn the model re-reads its entire growing context — the goal plus every prior step and tool result. Later steps carry more context than earlier ones, so the cost compounds rather than adding linearly.

4What's the over-engineering trap, and what's the truly "advanced" move?›

Reaching for an agent because it's impressive when a simpler tool is better, cheaper, and more reliable. The advanced move is the opposite: choosing the lightest tool that does the job — sometimes that's a script, a single prompt, or just doing it yourself.

That's Stage 3. Next, you stop choosing tools and start building one →