Pricing & economics

Execution is pay-per-use in ANM, metered per resource actually consumed, priced by a versioned policy (currently v1), and split exactly between the platform and the developer. All money is integer nANM (1 ANM = 10⁹ nANM) — never floats.

The metering formula

price = baseCall
      + cpuMs        × cpuMsNanm          # host-measured container wall time
      + memoryMbMs   × memMbMsNanm        # configured MB × billed ms
      + aiTokensIn   × aiTokenInNanm
      + aiTokensOut  × aiTokenOutNanm
      + ceil(egressBytes / 1024) × egressKbNanm
      + gpuMs        × gpuMsNanm
      + perCallNanm                        # the developer's surcharge

price = max(price, marginFloor)            # see below
split: price == platformFee + developer (+ provider), exactly, in integer nANM

Live unit rates (policy v1)

Billed CPU is the host-measured container wall time — the resource the platform reserves for you — never the guest's self-reported number. Egress rounds up to whole KB. Rates are operator configuration: a new policy version reprices future executions only; historical rows keep the rates and fee they settled at.

The margin floor

The platform refuses to sell compute below its configured gross margin (target 60%). When the metered price would be below the floor, the price is raised to it:

marginFloor = ceil( cogs × 10000² / ((10000 − targetMarginBps) × feeBps) )
# at the defaults (60% target margin, 20% fee) that is cogs × 12.5

In practice the floor dominates for long-running, low-rate executions (e.g. a function that waits 60 s on an upstream), and the metered sum dominates for short bursts. The pre-execution POST /api/cloud/v1/estimate shows both the typical and worst case with the floor applied — the number shown is the number charged.

The split

• Platform fee: 20% (2000 bps) of the price — Founding Developers pay 10% for their first 12 months.
• Compute provider: 10% when a fleet provider ran the execution (0 when the platform ran it locally) — see Compute providers.
• Developer: the exact remainder. Platform and provider shares are computed by basis points; the developer takes what is left, so integer rounding can never mint or lose a nANM: price == platformFee + developer + provider is asserted before settlement is allowed to commit.
• The fee rate is snapshotted onto every execution and purchase — later policy changes never rewrite history.

Failures

You pay for resources your request actually consumed, never for an outcome that did not happen:

• Rejected before running (quota, funds, capacity): charged nothing; consumed quota is refunded.
• Failed / timed out: real CPU, memory and AI were burned, so the caller pays the metered resource cost — with no developer surcharge and no margin floor. The developer earns nothing from a failed run.

Free tier

• 50 executions/day and 500/month per caller (anonymous callers are counted by salted IP hash), on public, auth-optional, zero-surcharge functions.
• 20,000 free AI tokens/day.
• Calls to your own functions consume your plan's included quota instead of ANM.
• A platform-wide monthly free-tier cost ceiling can pause free execution rather than run it at an unbounded loss.

Plans (USD subscriptions)

Execution is paid in ANM; plans set your limits and entitlements — how many functions you can publish, monthly included executions, concurrency, schedule frequency, log retention, priority.

*"unlimited" means no numeric cap from the plan — the platform's hard safety ceilings still apply and every expensive resource still meters. Past an included allowance, plans with overages accrue metered USD charges; plans without are refused with a clear 402 quota_exceeded.