DigitalOcean Agent Droplets: When the $50 Plan Pays Off

The $50 Agent Droplets plan is cheaper than paying as you go only when you would spend more than $50 a month on DigitalOcean Managed Agents anyway, and then it saves you at most $8.82. For the coding agent we built last month, $50 of usage is about 780 runs. We know what a run costs because we read the September invoice line by line. The invoice also showed something the token math hides: on our invoice, every session's token lines were rounded to the cent, with a one-cent minimum, so our five recorded runs were billed $0.32 for tokens worth $0.274.

Agent Droplets launched on 1 October 2026 as a public preview. The name suggests a server you rent. It is a monthly plan that prepays and discounts the usage you already pay for in Managed Agents. This post shows the plan math, the real cost of our runs, the break-even for two kinds of agent work, and a calculator you can run with your own numbers.

TLDR

• Pro costs $50 a month and covers $58.82 of usage at list price (15% off). Team costs $200 and covers $250 (20% off). After that, usage continues at list price.
• Pro beats pay as you go above $50 a month of discounted usage and saves at most $8.82. Team beats Pro above $208.82 and saves at most $50.
• The discount covers compute, memory, storage, tools, egress and DigitalOcean-hosted models such as GLM-5.3 and Kimi K3. Claude and GPT are not discounted.
• Our five recorded issue-to-PR runs were billed $0.064 per run, $0.107 per merged pull request. At that rate, Pro is cheaper from about 782 runs a month.
• One 39-minute interactive session on GLM-5.3 was billed $0.78, almost all of it tokens. At that rate, Pro is cheaper from 65 sessions a month.
• On our invoice, every token line of every session matched max(1 cent, amount rounded to the cent). That added 17% to our five runs and 25% to all 13 sessions on the invoice. Compute for sessions of about a minute was billed at $0.00.
• DigitalOcean's docs do not say whether unused plan balance rolls over. Check that before you subscribe.

Prerequisites

• A DigitalOcean account. Nothing here needs a plan; we did not subscribe to one.
• Node 20 or later, to run the calculator from the companion repo.
• Optional: an API token with billing read access, if you want to price your own invoice with the same scripts.

What you actually buy

Managed Agents runs coding agents such as Claude Code, Codex and OpenCode in microVMs, and bills for the parts separately: compute, memory, storage, tool calls, egress and model tokens. Agent Droplets does not change any of that. It adds a monthly fee that funds a balance, and your usage draws from that balance at a discount.

Plan	Monthly fee	Discount	Usage covered at list price
Free trial	$5 credit	none	$5
Pro	$50	15%	$58.82
Team	$200	20%	$250.00

The figures come from DigitalOcean's Harness Runtime pricing page and the Agent Droplets pricing page, both read on 10 October 2026.

Not everything is discounted. The docs list what is:

• Harness Runtime compute (CPU) and memory
• Session storage, snapshots and custom templates
• Inference on DigitalOcean-hosted models, such as Kimi K3 and GLM-5.3
• Action Gateway tools: code interpreter, browser automation, web search and web fetch
• Public internet egress

Third-party models such as Anthropic Claude and OpenAI GPT are billed at standard rates and do not draw down the plan balance at a discount. So if your agents run on Claude, the plan saves you nothing on the biggest part of the bill.

When the balance runs out, nothing stops. In DigitalOcean's words, "you just move from the discounted rate to list price for the rest of the month."

The math

Write your monthly discount-eligible usage at list price as U: compute, memory, storage, tools, egress and DigitalOcean-hosted models. Claude, GPT and other charges the plans do not discount are added to every line unchanged, so leave them out of U. Then:

Pay as you go:  U
Pro:            50  + max(0, U - 58.82)
Team:           200 + max(0, U - 250)

Pro costs a flat $50 until your usage passes $58.82, then grows with usage again. So Pro is cheaper than pay as you go as soon as U is above $50, and the gap never grows past $58.82 - $50 = $8.82. Team overtakes Pro where Pro's cost reaches $200, at U = $208.82, and its saving against pay as you go is capped at $250 - $200 = $50.

The shape is the whole story. Below $50, Pro costs more than it saves. Between $50 and $208.82, Pro is the cheapest, by at most $8.82. Above that, Team is cheapest, by at most $50 against pay as you go. A plan is worth it only once you know that your usage sits reliably above those lines.

The useful question is what $50 of usage looks like in agent runs. For that, we needed the real cost of a real run.

What our agent runs actually cost

Last month we built an issue-to-pull-request agent on Managed Agents: OpenCode on DeepSeek V4 Pro in a 2 vCPU / 4 GB microVM, one session per GitHub issue. That post estimated the model cost of each run from the token counts that the agent reported. The September invoice has now arrived, and it tells a different story.

The invoice API returns one line per session for compute, and one line per session for each kind of token: input, output and cache read. Stage 1 of the companion repo pulls those lines, and stage 2 prices them.

These are the five recorded runs, matched to their invoice sessions by the session name in each run's log:

Run	Outcome	Input / output / cache-read tokens	Exact list price	Billed
Issue #1	Merged	8,989 / 1,028 / 61,696	$0.0407	$0.05
Issue #2, first try	Closed in review	15,136 / 1,852 / 105,472	$0.0695	$0.08
Issue #2, second try	Push refused	15,184 / 2,272 / 82,176	$0.0629	$0.07
Issue #2, third try	Merged	14,984 / 1,609 / 57,344	$0.0516	$0.06
Issue #3	Merged	9,514 / 2,113 / 72,192	$0.0490	$0.06
Total	3 merged		$0.274	$0.32

Two things stand out.

Cache-read tokens are most of the volume. An agent sends its growing conversation to the model on every step, and the provider bills the repeated part as cache reads, at one fifth of the input price for this model. Our earlier post counted only input and output tokens, so it put the model cost at about two cents per run. With cache reads and the invoice's rounding, the real figure was five to eight cents. We have added a correction to that post.

Each line was rounded to the cent, with a one-cent minimum. We checked a rule against all 31 token lines on our September invoice: billed = max($0.01, exact amount rounded to the cent). All 31 match. That is a pattern on one pay-as-you-go invoice, not a published billing policy, but it is consistent. On a long session this hardly matters. On short agent runs it does. For our five runs it added 17%, and across all 13 sessions on the invoice, including short probes, it added 25%: $0.62 billed for $0.497 of tokens. A probe that produced four output tokens was billed a full cent for them.

Compute was billed at $0.00. Compute is billed per second for the CPU a session actually uses, plus its peak memory. Even at full use, 2 vCPU and 4 GB list at $0.126 an hour, and the five sessions existed for 38 to 79 seconds each, so each one's compute was less than three tenths of a cent. The invoice shows $0.00 for every compute line. Unlike the token lines, compute lines below a cent were not raised to a cent.

So one recorded run cost $0.064 on the bill, tokens and compute together. Two of the five runs did not end in a merged pull request, so a merged pull request cost $0.107.

Turning $50 into runs

Stage 3 finds the first monthly volume at which each plan is cheaper. These are estimates: they assume a plan draws down its balance at the same charges our pay-as-you-go invoice showed, which we could not check without subscribing.

782 runs a month is about 26 runs a day, every day. A team that points an agent at every new issue in a busy repository might get there. A team that uses it a few times a day will not, and pays $50 for less than $50 of usage.

One long session: $0.78 for 39 minutes

Short runs are the worst case for the rounding rule. To see the other end, stage 4 of the repo ran one longer session the way a person works with a coding agent: six prompts, one after another, in the same 2 vCPU / 4 GB session, on GLM-5.3, a DigitalOcean-hosted model that the plans discount. The prompts asked the agent to read a small Python package, add ISO 8601 duration parsing, add a command-line entry point, rewrite the error messages, add type hints and documentation, and then review its own changes. The session ran for 39 minutes, changed five files with 346 added lines, and finished with 45 tests passing. Nothing was pushed.

It appeared on the invoice preview the next morning:

Three things changed from the short runs:

• The rounding rule stops mattering. The three token lines match the same rule, but on $0.74 of tokens it moved the bill by less than a cent.
• Cache reads are a third of the bill. Each prompt sends the whole conversation so far. The cache makes that cheap per token, but the session read 971,520 cached tokens, 37 times its 26,087 fresh input tokens, and paid $0.25 for them. A long session pays for its own history.
• Compute is still small. $0.04 for 2,318 seconds. At full use, 2 vCPU and 4 GB would list at about $0.08 for that time, so the session was billed for roughly half, which fits billing for the CPU actually used. Tokens were 95% of the bill.

At $0.78 a session, the break-even comes much sooner:

Pro is cheaper from 65 sessions like this a month, about three every working day for one person. Team is cheaper than Pro from 268, which is about 13 people each running one such session every working day. This is one session on one model, so treat $0.78 as an example, not a rate. A longer conversation reads more cache, and the same token counts on Kimi K3 would list at about $1.91, 2.6 times as much.

Where the plan makes sense

• Agents that run for hours. Long interactive sessions use far more tokens than our short runs, and a busy agent keeps the CPU working. Our one recorded 39-minute session cost 12 times as much as a short run, and sessions like it reach the $50 and $208.82 lines much faster.
• Agents on DigitalOcean-hosted models. GLM-5.3 at $1.40 / $4.40 per million input / output tokens and Kimi K3 at $3 / $15 are discounted. Claude Sonnet 5.5 at $2 / $10 is not, even though it is billed through the same account.
• Many people sharing one account. Every plan includes unlimited seats and agents, so the whole team's usage counts toward one balance. With short runs like ours, ten people would need about 11 runs each per day to pass $208.82; with long sessions, far fewer.

Where it does not

• Occasional or bursty use. Below $50 a month, pay as you go is cheaper, and the free trial's $5 credit covers a lot of short runs.
• Claude Code or Codex on their own vendors' models. The model tokens are most of the bill, and the plan does not touch them.
• Before you have a month of real usage. Run pay as you go for a month, then price the invoice. The scripts do that for you.

Price your own usage

Clone the repo and pass your own numbers:

git clone https://github.com/The-DevOps-Daily/agent-droplets-break-even
cd agent-droplets-break-even
node calc.mjs --runs 1500 --cost 0.064

To price your own invoice instead, run stage 1 with a billing-read token and your invoice id (or preview for the current month), then stage 2 on the file it writes. Stage 2 also checks the rounding rule against every token line, so you can see whether your bill follows it too.

What we could not conclude

• How a plan invoice looks. We stayed on pay as you go. We do not know whether the 15% discount is applied before or after the one-cent rounding, which matters for short runs.
• Rollover. As above, the docs do not say.
• A typical long session. We priced one. Its cost depends on the model, the length of the conversation and how much the agent reads back, so your sessions can cost a lot more or less than $0.78.
• Speed. Managed Agents is in preview, and DigitalOcean's preview terms treat benchmark results as confidential, so this post prices usage only.
• Prices after the preview. Plan terms and list prices can change before general availability. The repo keeps every price in one file with its source and the date we read it.

Summary

Agent Droplets is a commitment discount, not a cheaper server. It pays off only once your discounted usage reliably passes $50 a month, and even then it saves at most $8.82 on Pro and $50 on Team. Our short issue-to-PR runs cost six cents each on the bill, so a team would need about 780 of them a month before Pro is worth it. Sessions like our recorded long one reach it much sooner: that 39-minute session on GLM-5.3 cost $0.78, so about 65 of them a month pass the Pro line. Whichever you run, read your invoice before you subscribe: it showed us cache-read tokens and a rounding rule that the token counts alone did not.