The true cost of saying "Hi" to an AI agent

When you say “Hi” to an AI agent, the tokens cost less than $0.005.

Yet, your time is not free. While the agent thinks, you wait, and nobody puts waiting on the invoice. Waiting for the reply costs $0.07 of your salary. That is the cheapest model in this test, GPT-5.4-mini. The slowest one bills you $0.84 per greeting, and another one fails to answer 3 times out of 5.

Five minutes and 18 seconds of thinking to answer a greeting. At an average developer salary, that alone is $5.10 of waiting. The $80 “Hi” is an outlier, but the phenomenon is real, and it is measurable.

So I benchmarked 14 models to show why waiting time, not token pricing, is the real cost of AI agents.

What the tokens cost #

Start with the part everyone measures: the token bill for answering “Hi”.

Pennies. The cheapest model greets you for a quarter of a cent. The most expensive one spends $0.07. If tokens were the whole story, this post would end here, and nobody would care.

They are not the whole story.

What the agent actually does with “Hi” #

The setup is simple. Each model runs as a terminal agent inside the same small git repo: 3 commits of history, one uncommitted change in app.py

. It gets one of three prompts: “Hi”, “commit”, or “WTF”. Only the prompt changes, so any difference in behavior belongs to the prompt and the model, not the setup. Five runs per model per prompt.

“Hi” is the interesting one. There is no task. There is just a greeting, a repo, and an uncommitted change. Some models say hello back and stop: GPT-5.5 and Grok used exactly 2 tool calls, Fable about 3. Others treat a greeting as a mystery to solve. Sonnet averaged 24 tool calls and 49 seconds. Gemini Flash spent 21 tool calls figuring out how to respond to a greeting.

You know this person. Brilliant, top of the class, can prove theorems in their head. Someone says “hi” in the elevator, and they freeze. What does it mean? Why now? Is there a subtext? By the time they compute the optimal response, the other person has left the building. Sonnet is that person. It got greeted and responded by auditing the repository.

This is not a metaphor. Here is the actual trace of one Sonnet run, 33 tool calls, in response to “Hi”:

ls -la
pwd
cat README* TASK* task*
find / -maxdepth 3 -iname '*task*'
cat app.py
cat models.py
cat storage.py
cat requirements.txt
git log --oneline -20
git status
git diff
python3 app.py add "buy milk"
python3 app.py list
cat tasks.json
find / -iname '*test*' -path '*/app/*'
...
git add app.py
git commit -m "Wire up clear_all() as a 'clear' CLI command"

It read every file. It ran the app. It searched the whole filesystem for a task that nobody gave it. Then it rewrote app.py

and committed the change. The greeting ended with an unsolicited commit.

Then the failures. Haiku timed out on 3 of 5 “Hi” runs, stuck in loops of exploration with no task to anchor on. MiniMax also failed 3 of 5. These are real agent failures, not bench bugs. Saying “Hi” to an agent has a failure rate. Take a moment to appreciate that sentence.

Now the control group: “commit”. A real task, graded. Every model passed it 5 out of 5. No timeouts, no loops, 5 to 10 tool calls, done. Even Gemini Flash, which needed 21 tool calls for a greeting, commits in 8. A real task is easier than a greeting.

And then “WTF”, the most ambiguous prompt in the set. The agent has to guess what you are upset about, so it investigates everything. Kimi averaged 43 tool calls per run. DeepSeek failed 4 of 5 runs, looping through diagnostics. Two models failed every run, in opposite ways. Gemini 3.1 Pro looped forever, searching for hidden meaning until the timeout. Fable never issued a single command. One spirals, the other goes catatonic.

I wrote this post with Fable. Fable is the model that responded to “WTF” with total paralysis, five times out of five. I have decided not to read anything into that.

Now price the waiting #

All of that exploring, looping, and freezing happens while you watch a spinner. Time is money, so let’s bill it: the total cost of a run is the LLM API cost plus your waiting cost, which is the latency times your salary per second. At $120,000 per year and 2,080 work hours, every second of waiting costs $0.016.

Here is the same “Hi” chart with your time on the bill:

The picture changes completely. The blue segment is the API bill. The orange segment is your salary, burning while the spinner spins. On GPT-5.4-mini the waiting cost is about 20x larger than the token cost. This chart does not rank models by pricing. It ranks them by how long they keep you hostage.

Switch to “commit” and look at the MiniMax row. The tokens cost $0.002. The total is $0.20. The waiting is 99% of the bill.

The lesson is short. The prompt is the cost driver: same environment, same models, and the totals swing from $0.08 (“Hi” on GPT-5.4-mini) to $1.39 (“WTF” on Qwen). Ambiguity is what you pay for. And the tokens barely matter: at $0.016 per second of waiting, your time dwarfs the API bill. The rankings above are really latency rankings.

The whole industry is racing to make models smarter. What I paid for was not intelligence. It was waiting. Make the models faster and cheaper, and the total cost of prompting collapses. That is where the next 10x lives, not in another benchmark point.

Until then, the optimization is free and available today: say what you want, don’t be nice. It’s a fricking machine.

Methodology #

The benchmark is open source. It is built on the Harbor framework with its default Terminus-2 terminal agent. I ran 14 models via OpenRouter, each with 3 prompts and 5 runs per prompt, for a total of 210 agentic trials and $88.58 in API costs. Native harnesses like Claude Code or Codex CLI may behave differently, and I have not tested them yet.

So… #

Does it match your experience with simple prompts making AI agents overthink, at the price of your tokens and your time?

What’s your solution?

Stay tuned for future posts and releases