The Idle-Compute Tax: What Vercel's Active CPU and Netlify's Durable Functions Reveal About Serverless AI Bills

Your AI agent spends most of its life doing nothing. Not broken — just waiting.

A typical serverless AI request waits 3 to 8 seconds on an LLM response while burning maybe 80 to 200 milliseconds of actual CPU. Under wall-clock billing, you paid for all 8 seconds. Under Active CPU billing, you pay for 200 milliseconds. That gap is the idle-compute tax — and two 2026 platform moves, Vercel's Active CPU pricing and Netlify's Durable Functions, finally put a price tag on it.

Both fixes are real improvements. Both also reveal how much the old model was charging you for waiting. And neither erases the comparison that matters most: what the same idle-heavy workload costs on a flat-rate box that never metered the wait in the first place.

The answer up front: what the idle tax costs in dollars​

We priced the same reference AI workload everywhere: a serverless endpoint that handles an agent tool loop — receive prompt, call LLM, parse, call tool, call LLM again. Wall-clock time per invocation: 5.0 seconds (dominated by two LLM waits). Active CPU per invocation: 0.20 seconds. Memory: 1 GB. Same math the platforms use, at live 2026 rates.

At 10K AI invocations per month, the wall-clock model charges roughly 13× more than Active CPU for the same work — and that multiplier is conservative, because real agent loops often idle 90 to 97% of wall-clock time. The flat Hetzner box charges the same €3.99 whether you run 1K or 100K idle-heavy invocations, because it never metered the wait.

The rest of this post shows how we got there, why AI workloads are so idle-heavy, and where each platform's fix still leaves gaps.

Why AI workloads break wall-clock billing​

Serverless billing was designed for milliseconds of CPU-bound work: resize an image, validate a webhook, render a page. You get CPU, memory, and a clock. The clock runs from invocation start to return.

AI workloads invert that shape.

A single agent turn looks like this:

1. Request arrives (10ms CPU — parse JSON)
2. Call LLM API (0ms local CPU, 2,500ms wall-clock wait)
3. Parse LLM response, call a tool or database (50ms CPU)
4. Call LLM again to summarize (0ms local CPU, 2,000ms wall-clock wait)
5. Format and return (40ms CPU)

Total: ~90ms CPU, ~4,600ms wall-clock. CPU utilization: ~2%.

Research backs this up. The 2025 study "Getting to the Bottom of Serverless Billing" found more than 42% of serverless requests use less than 50% of their allocated CPU, with memory correlation at only 0.397 — functions hold resources they barely use. For AI workloads, the gap is extreme. DBOS's public analysis of Lambda AI workloads measured 50× cost overhead from waiting, noting agent functions spend "most of their time idle waiting for the LLM to respond" while wall-clock billing charges for every waiting millisecond.

The irony: the slowest part of your AI app — the part your user notices — is the part your serverless bill was most efficiently taxing.

Two platforms shipped fixes in 2026. Both tell you, by their existence, how large the tax was.

Vercel Fluid Compute: pay for CPU, not the wait​

What changed: In June 2025, Vercel made Active CPU pricing the default for all Functions running on Fluid Compute (its concurrency-based runtime, successor to per-invocation microVMs). The pitch: you pay for CPU only while it is actively executing, not during I/O wait on an external API.

How it is priced (2026 live rates, iad1 region):

Memory still bills on wall-clock (the instance holds memory while waiting), but CPU — the dominant line for compute-heavy billing — now bills only active cycles. Vercel also raised default limits with Fluid: default timeout 300 seconds (5 minutes), up to 800 seconds on Pro/Enterprise, with larger memory and CPU now feasible because Active CPU pricing made long waits cheaper to offer.

Before vs after for our reference workload (5s wall, 0.2s CPU, 1 GB, 10K invocations):

• Before (wall-clock GB-seconds): 5s × 1 GB × 10K = 50,000 GB-seconds = 13.9 GB-hours. At legacy ~$0.60/GB-hour effective: ~$7.10.
• After (Active CPU): 0.2s × 10K = 2,000 CPU-seconds = 0.56 CPU-hours × $0.128 = $0.07 CPU. Memory: instance lifetime still ~5s × 10K = 13.9 GB-hours × $0.0106 = $0.15. Invocations: 10K × $0.60/1M = $0.006. Total: ~$0.22. (With concurrency and provisioned-memory sharing, Vercel's realized numbers land near $0.55 — the direction is what matters: an order-of-magnitude drop.)

Vercel's own changelog frames this as "lower pricing" — and for AI workloads it is, dramatically. But the improvement also documents the prior overcharge: the platform was billing roughly 90%+ of wall-clock time as if it were compute.

What Active CPU still bills: memory hold time, invocations, and egress. An AI app that streams tokens back still holds memory for the full wall-clock. And the $20/user/month Pro seat fee (with a $20 included usage credit) sits in front of any usage — a team of five pays $100 before the first invocation, a point the Hetzner comparison makes sharp.

Netlify: lift the timeout, keep the meter​

Netlify approached the same idle problem from the other end: not "bill less for waiting" but "let you wait longer."

The timeout ladder:

• Standard Functions (AWS Lambda under the hood): originally 10 seconds, now 26 seconds default for synchronous responses.
• Background Functions: up to 15 minutes, asynchronous — return 202 immediately, run detached.
• Durable Functions (2026 evolution, building on background + scheduled primitives): long-running, resumable execution past the synchronous limit, aimed at agent loops, build-like tasks, and multi-step orchestrations where the function should not have to return in 26 seconds.

Netlify's model is less a billing reform than a capability unlock: if your AI workflow needs 90 seconds of wall-clock time across three LLM calls, standard functions timed out — Background and Durable functions let it finish. The billing remains wall-clock-based (duration × memory, per the Lambda lineage), unlike Vercel's Active CPU split.

Cost for the same workload on Netlify:

At 5 seconds wall-clock, 1 GB, 10K invocations, the math resembles pre-Fluid Vercel: ~13.9 GB-hours of billed duration. At public Netlify usage rates (bundled into plan + overage), that lands near $5 to $7 — similar to wall-clock Vercel, without an Active CPU discount. The value Netlify delivers is not a cheaper second but a possible second: without Background/Durable, the invocation would have failed outright. For AI workloads that are long but not CPU-hot, "it completes" beats "it times out," even at wall-clock rates.

The pattern is telling: Vercel re-engineered billing to avoid charging for idle; Netlify re-engineered execution to tolerate idle. Both acknowledge the same underlying workload shape — the difference is which half of the equation they fixed first.

The recomputed bill: three traffic levels, one lesson​

The single-invocation math hides the scaling story. Here is the same AI workload (5s wall, 0.2s CPU, 1 GB) priced across three monthly volumes, using live 2026 rates. Vercel Active CPU includes CPU + memory + invocations. Netlify is wall-clock GB-seconds. Hetzner is a flat CX23 at €3.99/month (2 vCPU, 4 GB RAM, 40 GB NVMe, 20 TB included traffic) or CPX22 at €7.99/month (3 vCPU, 6 GB, 80 GB NVMe).

Two observations:

1. The idle multiplier is the bill. At 96% idle (0.2s / 5.0s), wall-clock costs ~25× the Active CPU cost for CPU alone. Even after Vercel's fix, memory-hold time still bills on wall-clock, so the realized gap is ~10–13× — still the largest single variable on the invoice. Show a workload with 0.5s CPU instead of 0.2s and the gap shrinks to ~10×; show one with 0.05s CPU and 15s wall-clock (a slow agent loop) and it widens past 50×. The sensitivity is the point — AI workloads live at the high-idle end.

2. The flat box reframes the question. At 10K invocations, Vercel Active CPU and Hetzner are in the same ballpark ($0.55 vs €3.99). At 100K, the flat box is already cheaper. At 1M, it is an order of magnitude cheaper — not because Hetzner is magically efficient, but because the flat box never invented a per-idle-second meter to begin with. You pay for the machine, not for each wait.

That is not an argument that everyone should self-host. It is an argument that the right comparison for AI workloads is not "which serverless vendor charges less per idle second" but "what does it cost to not charge per idle second at all."

What self-hosted never pays — and what it does​

An owned Hetzner box under Cluster API (or any self-hosted PaaS) has a fundamentally different cost shape for idle-heavy work:

• No idle-compute tax. A long-running container holding an agent loop consumes memory and a process slot while waiting on an LLM — just like on serverless. But there is no meter ticking per waiting second. Whether the container idles 2 seconds or 20, the monthly cost is the same €3.99 — €7.99. The "fix" for idle billing was never needing the fix.

• No timeout cliff. No 26-second, 5-minute, or 15-minute wall to re-architect around. A background worker, a WebSocket, a persistent queue consumer — they just run. Netlify solved this with a new function type; Vercel solved it with a higher default limit; self-hosted never had the limit.

• Bandwidth at zero marginal cost. The CX23 includes 20 TB of traffic, CPX/CAX lines include 20 TB as well. A token-streaming AI app that pushes 500 GB or 2 TB of egress pays no overage line — the same egress that costs $0.15/GB on Vercel ($40 per 100 GB after the credit) or $0.02–$0.15/GB elsewhere.

What it does pay is operational cost: you own the machine, the updates, the deploy pipeline, and the capacity plan. For a side project with 500 invocations a month, that tradeoff rarely wins — serverless at Active CPU rates is genuinely cheap at low volume. For a production AI product handling 100K+ idle-heavy invocations monthly, the math inverts, and the flat box wins even after pricing in an operator's time at a realistic hourly rate.

The June 2026 price adjustments matter here: Hetzner raised CX/CAX shared-vCPU lines ~30–37% (CX23: €3.29 → €3.99) and dedicated-vCPU CPX/CCX lines ~113–176% (CCX13: €16.49 → €42.99) effective June 15, 2026, citing DRAM/NVMe cost pressure. Even after the hike, the shared-vCPU lines — the actual workhorse for idle-heavy container workloads — remain the flat-rate anchor in every comparison on this list, including this one. The dedicated-core hike is a separate story for a separate workload.

The signal inside the fix​

Vercel Fluid Compute with Active CPU and Netlify Durable Functions are good, needed changes. They let AI-native apps run on serverless without absurd bills or timeout hacks.

They also prove, by the magnitude of the correction, how poorly wall-clock billing fit AI workloads from the start. A billing model that drops 90% when you stop counting idle seconds was taxing idle seconds. A platform that needs a new "durable" primitive to survive a 90-second agent loop had a durability gap, not just a pricing gap.

For teams evaluating where to run AI agents, the decision tree is now:

• Under ~10K idle-heavy invocations/month: Vercel Active CPU or Netlify Background/Durable is pragmatic and cheap; the idle tax at low volume is small in absolute dollars.
• 10K–100K/month: run the table for your actual wall-clock/CPU ratio; Active CPU narrows the gap but the flat box starts winning, especially with egress.
• 100K+/month or persistent agents: the flat box wins outright, and the question shifts from "which meter is fairest" to "why is there a meter on waiting at all."

The idle-compute tax was always there — sitting in the gap between wall-clock time and CPU time, compounding with every LLM wait. These two platform moves just made it visible. What you do with that visibility — optimize around the meter or step off it — is the real pricing decision.

Self-hosting AI workloads shouldn't mean metering every idle second. Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with a Render-compatible API and an MCP server your agent can call directly. No per-idle-second billing, no timeout to durable-migrate around — just a flat Hetzner box under Cluster API that your agent can deploy to. Star the repo on GitHub or deploy your first app today.