Notion's Custom Agents Stopped Being Free on May 4. I Run My Client OS on Them — Here's the $10/1,000-Credit Burn Math and the Cap-or-Rebuild Call I Made

On May 3 my Custom Agents cost $0. On May 4 the same agents started drawing down credits at $10 per 1,000, and the first projection put my client OS at roughly $340/month if I changed nothing.

The day the meter turned on

I had been running Notion Custom Agents inside a live client operations workspace – the DVNC client OS – for the back half of the free beta. A triage agent reading inbound briefs, a daily digest agent rolling up status across active engagements, a doc-sync agent keeping a few shared knowledge bases aligned with the source-of-truth pages. Three always-on agents, plus a handful of triggered ones. Cost line: zero.

Notion flipped the meter on May 4, 2026. Custom Agents went from free beta to metered General Availability at $10 per 1,000 Notion credits, billed on top of the seat subscription and gated to Business and Enterprise plans only. There is no downgrade path that preserves them – Plus and Free never had Custom Agents in the first place, so "drop a tier to keep the feature" is not an option anyone has. You're either metered on Business+ or you don't have the feature at all.

For the first 48 hours after the flip, I let the agents run untouched, on purpose, because I wanted real burn data rather than a projection. One operator I follow posted a public number of around $337 burned in a single month on a comparable setup – within shouting distance of my own 30-day projection, which told me my burn was not a configuration mistake. It was the new floor.

This is the part most pricing recaps miss. May 4 was not a price increase. A price increase is when a line item goes from $40 to $55 and you update the budget. This was a free-to-metered conversion, which is a different category of event: every cost assumption baked into how the agents were configured, scheduled, and scoped was now wrong, because all of those decisions had been made under "credit cost is zero." The first job was not to cut spend. It was to re-derive the workflow from a premise that no longer existed. Notion did something structurally similar on the developer side earlier in the year (see the external-agents credit cliff), so the pattern was readable, but knowing the pattern does not pay the bill.

Where the credits actually went

The first useful thing I did was instrument per-agent burn, because Notion's UI shows you workspace-level credit consumption but does not, by default, give you a clean per-agent breakdown of where the meter ran. Credits are workspace-shared and reset monthly, which sounds neutral until you realize it means a noisy agent silently taxes every other AI workflow in the same workspace.

Three agents accounted for roughly 70% of the burn. Not five, not eight. Three.

The triage/intake agent – the one polling a shared inbound page and classifying new briefs – was the worst offender by a wide margin. It was configured to check every 15 minutes, 24/7. Most of those checks found nothing new, but each run still cost credits. Idle polling on unchanged data is the trap. The agent was doing exactly what I told it to, and what I told it to was expensive once the meter turned on.

The daily client digest agent was the second-largest line. One run per active engagement per day, fanned out across the active client list. The per-run cost was reasonable; the volume was the issue. Multiplying a sane per-run number by the number of engagements times 30 days produced a monthly figure that, on its own, was higher than the entire previous month of Notion seats.

The doc-sync agent was third and the most interesting case. Per run it was the cheapest of the three, but it triggered on edits, and a single human session editing a shared page could fire it a dozen times. The agent was effectively rate-coupled to human typing speed, which is a configuration choice nobody would make on purpose at $10 per 1,000 credits.

The rough monthly math, reconstructed from the first ten days post-flip and extrapolated, looked like this. Triage agent: ~$160/month at the polling cadence I had it on. Digest agent: ~$95/month at the current engagement count. Doc-sync: ~$45/month at observed edit volume. The remaining ~$40/month was spread across four lighter agents. Total in the $335–$345 range, which matched the public number I had seen from another operator running a similar shape of workspace.

This sits on top of an operations stack I have written about before – see the $387/month baseline – and adding a $340 line to that baseline would have moved the whole stack across a threshold I had explicitly set. So this was not "a small overage to absorb." It was a structural problem.

The three-way decision tree

Three branches, real numbers behind each, and only one of them was the right answer for my specific workload. The same numbers will produce a different answer for someone else's, which is the point of running the math instead of taking a recommendation.

Branch A – stay fully metered, change nothing. This is the correct call when run count is low, per-run value is high, and billing predictability matters less than absolute cost containment. For a workspace doing a small number of high-value agent runs per day – say, an agent that produces one carefully scoped output that saves a person an hour – metered pricing is fine. The $10-per-1,000-credits number is not the scandal; the scandal is running agents that don't pencil at any per-run cost. My ceiling for staying fully metered would have been roughly $80/month for this workspace, given what it produces. The projection was four times that. Branch A was out.

Branch B – cap and re-scope. Kill always-on polling. Convert agents from interval-triggered to event-triggered or manual. Collapse the digest agent from per-engagement to one batched daily run that produces a single rolled-up output. Configure the doc-sync agent to debounce so it fires once per editing session instead of once per edit. The re-scoped projection landed at roughly $70–$85/month – under the ceiling, with the same essential outputs and a meaningful loss of "instant" feel on the triage flow. The triage agent now runs every two hours instead of every fifteen minutes, and that delay is a real product cost I had to look at honestly.

Branch C – rebuild on owned infrastructure. Take the heaviest agent – triage – and rebuild it outside Notion: a Cloudflare Worker on a cron, calling Claude directly, writing results back into the Notion page via the API. One-time build cost: roughly 6–8 hours of focused work for someone who has done this shape of thing before, which I have. Ongoing cost: Worker plan I already pay for, plus Claude API tokens that land in the low single-digit dollars per month at this volume. Founders are running comparable self-hosted agent stacks publicly, and the math works once per-run volume crosses a break-even line.

The break-even calculation is the only part that matters. At my triage agent's run rate, the metered Notion cost was ~$160/month. Rebuilt on owned infrastructure, ongoing cost was ~$4/month. Build cost amortized over 12 months at a generous $150/hour internal rate: ~$100/month for the first year if I'm strict about counting my time. Year-one all-in for the rebuild: ~$104/month vs. ~$160/month metered. Year-two onward: ~$4/month vs. ~$160. Rebuild pays back inside year one and compounds.

The same operator P&L discipline I applied to the Codex offer applies here, just on the other side of the question: there I was deciding whether to switch tools for a free incentive; here I'm deciding whether to rebuild around a tool whose economics changed underneath me. Same framework, opposite direction.

The call I actually made: hybrid. Rebuild the triage agent on a Worker (Branch C, applied only to the heaviest single line). Cap and re-scope the digest and doc-sync agents (Branch B, applied to the middleweight). Leave the four lighter agents fully metered (Branch A, applied to the long tail).

Projected monthly cost under the hybrid: $45–$55 ongoing once the rebuild is shipped, with a one-time time cost of about 7 hours. Compared to the do-nothing $340 projection, that is roughly $290/month saved at the cost of one focused build session. The 30/60/90 cost line: month one absorbs the rebuild hours and runs partially metered ($110 actual cost equivalent counting time), month two lands near steady state ($55), month three steady state ($45).

What I'd do differently, and the part I'm slightly embarrassed about: I should have instrumented credit-per-agent from day one of the beta, not after the meter flipped. The beta period was the free window during which I could have measured exactly what each agent would cost under the eventual metered pricing – Notion published the credit rates well in advance – and I treated "free" as "don't bother measuring." Reconstructing the per-agent burn after the fact took longer than measuring it in real time would have. That is a rule I now apply everywhere.

The rule I now apply before any tool gets an always-on agent

The lesson is not "Notion Custom Agents are too expensive." Some of mine still run on Custom Agents and will keep running there. The lesson is narrower and more useful: free beta automation is a liability on your dependency graph, not a feature.

When a vendor offers an unmetered automation feature in beta, what they are offering is a free option for you to wire your workflow around a pricing model that does not exist yet. The moment the model exists, you either accept whatever the metered numbers turn out to be, or you do the rebuild work under time pressure. The cheap moment to do the work is before the meter turns on, not after.

The test I now run before any free beta automation gets wired into a critical path:

1. Price the metered version before the meter exists. If the vendor has not published rates yet, model a plausible one based on comparable products and ask whether the agent still pencils.
2. Instrument per-run cost from day one. Treat the free period as a measurement window, not a free lunch.
3. Identify the rebuild path before you need it. Know which agents you would rebuild on owned infrastructure if the economics flipped, and roughly what that build costs in hours.
4. Cap always-on cadence to the slowest acceptable interval. If a 2-hour poll is acceptable, do not configure 15-minute polling just because you can. Cadence is a cost dial that is free to turn down in beta and expensive to turn down after the fact, because by then humans have built habits around the faster cadence.

The hybrid I landed on for the client OS is not elegant. Three different cost models running in parallel across one workspace is more configuration than I would design from scratch. But it matches the actual shape of the work, and it brings the monthly number back inside the ceiling I set for this workspace before the meter turned on. That is the only test that matters.

Free beta automation is a liability, not a feature. Price it before you wire it in, or rebuild it under pressure after someone else does.

How much do Notion Custom Agents cost after May 4, 2026?

$10 per 1,000 Notion credits, billed alongside the subscription. Available on Business and Enterprise plans only – Free and Plus never included Custom Agents.

Can I keep Custom Agents on the Plus plan to avoid credits?

No. Custom Agents were never on Free or Plus, so there is no downgrade that preserves them. You are either on Business+ and metered, or you don't have the feature.

What happens when a workspace runs out of credits?

Custom Agents stop. Other Notion AI features like Meeting Notes and the standard Notion Agent continue to work up to a fair-use limit on the underlying plan.

Is it cheaper to rebuild agents on my own infrastructure?

Only past a break-even run volume. Below it, the metered credit cost beats the build-and-maintain hours. Above it – particularly for always-on agents firing many times per day – owned infrastructure compounds in your favor from year two on.