How long do 100 AI video clips take? Concurrency slots by plan
100 jobs take ceil(100 / slots) waves: 100 on Free, 25 on Pro, 13 on Startup, 5 on Scale. Multiply by one job's time. Math and a runnable snippet.

Sume limits how many paid generation jobs run at once per workspace: 1 on Free, 4 on Pro, 8 on Startup and 20 on Scale. A batch of N equal jobs finishes in ceil(N / slots) waves, so 100 clips take 100, 25, 13 and 5 waves. Total time is waves times the time of one job, T.
Waves by plan
The last column assumes T = 3 minutes purely as an illustration. It is not a benchmark; measure your own T on a handful of jobs and substitute.
| Plan | Processing slots | Waves for 100 | Wall time | Illustrative at T = 3 min |
|---|---|---|---|---|
| Free | 1 | 100 | 100 x T | 300 min |
| Pro | 4 | 25 | 25 x T | 75 min |
| Startup | 8 | 13 | 13 x T | 39 min |
| Scale | 20 | 5 | 5 x T | 15 min |
Why Startup is 13, not 12
100 / 8 = 12.5, and a partial wave still takes a full job time, so it rounds up to 13. In practice workers claim queued jobs as slots free up, so the real figure is a little better than a strict wave model, but the ceiling is a good planning number.
Slots are separate from price
A slot is not a discount. Each clip still costs the same per second on every plan. What the higher plans buy is parallelism and a deeper queue. Prepaid top-ups do not raise the processing limit; the docs state concurrency is plan-only, with admin overrides for enterprise contracts. Always read generation_limits.concurrency_limit from a submit response rather than hard-coding this table.
import math
SLOTS = {"free": 1, "pro": 4, "startup": 8, "scale": 20}
def main() -> None:
jobs = 100
minutes_per_job = 3 # replace with your own measurement
for plan, slots in SLOTS.items():
waves = math.ceil(jobs / slots)
print(plan, waves, "waves", waves * minutes_per_job, "min")
main()What to do with the number
If the wall clock is the constraint, compare the cost of a bigger plan with the cost of the delay. Going from Pro to Scale takes a 100-clip batch from 25 waves to 5, a 5x speed-up for 10x the monthly fee ($400 against $40), but it also raises included usage from $40 to $800.
The same math for 500 and 1,000
The formula scales. For 500 jobs: Free 500 waves, Pro 125, Startup 63, Scale 25. For 1,000 jobs: Free 1,000, Pro 250, Startup 125, Scale 50. If a job takes 3 minutes, 1,000 jobs on Scale is 150 minutes, 2.5 hours; on Pro it is 750 minutes, 12.5 hours.
These are ceilings from a strict model. Jobs vary in length, and a slot that frees early starts the next job at once, so real batches tend to finish somewhat sooner. The takeaway is the ratio: moving from 4 to 20 slots cuts waiting by a factor of 5, and from 8 to 20 by a factor of 2.5.
Sources
Related posts
More in Developers
- Connect a new MCP client to Sume: five calls that prove it works
After you add https://mcp.sume.com/mcp to a new client, run mcp_health, tools_list, tools_schema, account_me and catalog_list. What each result should show.
- Convert an SRT file to Sume caption cues in Python
Sume captions take no SRT upload, but cues carry the same start, end and text. A 26-line Python script turns an SRT into cues and posts them for $0.20.
- Cost per ad variant: build a ledger from usage.cost on Sume
Every completed /v1/videos poll carries usage.cost. Sum it by hook and ending to get the cost per ad variant before media spend. Node script and the caveats.
- Create an AI avatar and its first talking video in one bash script
Two Sume jobs in order: create the avatar, wait, then render a talking video with its handle. A bash script with curl and jq, plus the cost of both steps.
Written by Sume