The infrastructure story isn’t how many people open an AI app. It’s how much work keeps running after they stop typing.
Picture this. You tell an AI assistant to fix a broken app and make sure it works. Then you close the window and go make coffee. On the other end, the job has barely started.
That’s the question hiding behind DeepSeek Harness, whose team says it has 1.54 million daily active users and roughly 92 trillion tokens flowing through its official API every day. The user count makes the headline. What I find more interesting is what it might cost to turn every one of those requests into a long computational job.
You stopped typing a while ago, but the compute bill didn’t.
The Number Behind the Headline
Divide the two reported figures and you get about 60 million tokens per daily active user. I want to be careful here, because that’s just a ratio. It doesn’t describe what a typical person does. DeepSeek hasn’t published how usage is distributed, so we can’t tell whether everyone is a moderately heavy user or a small group is running automation around the clock.
That difference matters a lot. Serving millions of small jobs is a different planning problem from serving a few power users who never stop.
These are also company-reported numbers, not independently verified infrastructure data. They’re a reason to ask questions, not a license to announce how many power plants or GPU clusters DeepSeek needs.
Still, they raise a good question: what’s the right unit of AI demand? A person? A conversation? A finished task? For an agent platform, I’d bet on the third.
From Chat to Execution Loops
Take two requests.
“Explain why this test is failing.”
“Fix the failure, run the tests, and keep going until it’s verified.”
The first asks for an answer. The second hands over a whole process.
A coding agent given the second request might read through files, try a change, run the tests, hit a new failure, rethink its approach, and run them again. One sentence from the user turns into a chain of decisions, and each one can mean more model calls. Anthropic describes agents as systems that use tools and feedback from their environment to decide what to do next, which goes a long way toward explaining why a short instruction doesn’t mean a short job.
| Short chat exchange | Long-running agent task | |
|---|---|---|
| Example request | Explain an error | Fix and verify the error |
| What you get | An answer | A completed change |
| Cost question | What does one response cost? | What does the whole run cost? |
| Success means | The explanation helped | The task finished correctly |
This is a conceptual comparison, not a Harness benchmark.
To be fair, chat isn’t always cheap and agents aren’t always expensive. The real difference is that delegated work has an unpredictable path. Before it starts, neither the customer nor the provider knows how many attempts it will take. That uncertainty belongs in the infrastructure budget.
Why Tokens Aren’t Megawatts
It’s tempting to take 92 trillion tokens, plug in a benchmark, and declare a GPU count. That would claim far more precision than the disclosed numbers allow.
An analyst would first need to know what the total actually includes. How much is input and how much is generated output? How much comes from cache hits? Which models and which hardware serve the traffic? What throughput is realistic under real latency requirements? Without those answers, a token count can’t give you a defensible electricity bill.
There’s a second trap. Tokens processed aren’t the same as useful work delivered. A smooth, efficient task and a failing retry loop both add to the total.
So the volume tells you something is happening. It doesn’t tell you how efficiently.
For data center investors, that means resisting both extremes. The number doesn’t prove a capacity crisis is coming, and you shouldn’t wave it away just because inference may get cheaper. What’s missing is how much infrastructure each successful outcome takes.
The infrastructure challenge is also becoming a strategic issue for countries competing in AI, with GPU availability, cloud computing capacity and data-center expansion increasingly shaping their ambitions. India’s own AI infrastructure push illustrates this broader challenge.
Rewriting the Capacity Model
If I were planning capacity for an agent platform, I wouldn’t start with registered users. I’d ask three things.
How long does work stay active? A task that keeps running after the user leaves still has to be scheduled, monitored, and finished. The forecast that matters is how much unfinished work piles up, not just how many people show up.
How uneven is demand? A daily average can hide short windows where lots of tasks overlap. Test for peaks instead of assuming work arrives in a smooth stream.
Where does it stall? A slow task might be waiting on inference, an outside tool, a test environment, or a human decision. More GPUs won’t fix all of those.
To be clear, these are planning questions I’m proposing, not details about Harness’s internal setup.
They also change what good service looks like. In a chat product, speed is what people notice. With delegated work, the better promise might be: finish this correctly, within an agreed time and budget. That points toward separating urgent interactive requests from background jobs where customers are fine with flexible timing.
The goal shouldn’t be maximum activity. It should be dependable delivery.
Cheap Tokens, Expensive Tasks?
Lower token prices sound like pure good news. At the task level, it’s less clear.
Say two agents do the same job. Agent A costs less per attempt but often needs a second run. Agent B costs more per attempt but usually nails it. Which is cheaper?
You can’t say without measuring reliability, retries, and how much human effort goes into checking the result. That’s why cost per successfully completed task is a better buying metric than token price alone. A low price only helps if it buys useful work.
The same logic applies to total demand. If cheaper tokens lead people to delegate more, take on bigger projects, or add extra checks, total spending could go up even as each operation gets cheaper. That’s a scenario worth testing, not a law that efficiency always increases consumption.
And not every extra token is waste. Verification can be worth paying for. The test is whether the next step raises the odds or quality of completion enough to justify its cost.
What Operators Should Measure
A useful agent dashboard ties infrastructure use to outcomes. Here’s what I’d put on it:
- Cost per verified completion: count failed attempts and reruns too.
- Completion rate: decide what success means before you measure it.
- Tokens and model calls per task: watch the spread, not only the average.
- Task duration: separate real execution from waiting around.
- Retry frequency: spot repeated failures and loops that go nowhere.
- Peak concurrent work: test capacity against overlapping load.
- Human review effort: include the time spent checking and fixing results.
These are my recommendations, not reported Harness statistics.
The dashboard should also show stopping decisions. When does an agent retry? When does it escalate? When does it give up on an approach? A system that can’t answer those risks mistaking persistence for progress.
Price the Finished Work
Back to the opening scene: someone gives an instruction and walks away. What happens next could be valuable automation, or a pile of expensive failed attempts. The infrastructure challenge is telling them apart.
That’s why I think of “drain” as a question, not a diagnosis. High consumption could mean a lot of productive work, avoidable overhead, or some of both. Without outcome data, the headline number can’t say which.
The metric that matters probably isn’t how many people use an agent or how many tokens it burns. It’s what it costs to get the work done right.