Modal is a serverless platform with a Python-first SDK. Decorate a function, run modal deploy, and it becomes an autoscaling container with a GPU attached, billed per second of execution, scaling to zero when idle. Developers love it because there is nothing to provision and iteration takes a minute.
packet.ai is a GPU cloud in the classic sense: you rent a card by the hour, SSH in, run whatever you want. There is no function abstraction and no scale-to-zero. What you get instead is a much lower price per GPU-hour and total control of the environment. The interesting question is where the crossover sits.
Platform overview: packet.ai vs Modal
What Modal offers
Modal prices GPUs per second, quoted as hourly equivalents: T4 $0.59/hr, A10 $1.10/hr, L40S about $1.95/hr, A100 40GB $2.10/hr, A100 80GB $2.50/hr, H100 about $3.95/hr, H200 around $4.54/hr, B200 $6.25/hr. CPU and memory are billed separately on top, and there is a $30/month free credit on the starter plan.
- Python-native: functions, classes, schedules and web endpoints defined in code; no Dockerfiles required
- Scale-to-zero with cold starts typically in the tens of seconds for large images, mitigated by memory snapshots and keep-warm
- Per-second billing on GPU, CPU and RAM independently
- No raw instance access: you cannot SSH into a persistent GPU box or run non-Python services natively
What packet.ai delivers
Modal prices GPUs by the second inside a Python-native serverless runtime: no SSH, no persistent box, functions and containers that scale to zero. packet.ai prices the same silicon by the hour, and you get the actual machine: SSH access, root, whatever you want to run on it. Different deployment models, so the fair comparison is Modal's effective hourly rate against packet.ai's.
On every card both platforms list, packet.ai starts cheaper. B200 starts at $3.75/hr Dynamic against Modal's $6.25/hr, a 40% gap. A100 80GB Dedicated at $1.43/hr is 43% below Modal's $2.50/hr. L40S at $0.92/hr is 53% below Modal's $1.95/hr.
- Dynamic: scheduler-enforced multi-tenant, hourly, full SSH access to the machine. RTX 6000 Pro at $0.66/hr, B200 starting at $3.75/hr.
- Dedicated: a whole card, single-tenant, 99% SLA, for workloads that need guaranteed exclusive access. RTX 4090 at $0.39/hr, L40S at $0.92/hr, A100 80GB at $1.43/hr, B200 at $6.99/hr.
What Modal has that packet.ai does not: scale-to-zero, per-second billing on GPU, CPU and RAM independently, and a Python-native deployment model that turns a function into an autoscaled endpoint with no infrastructure code. If your workload is bursty and idles most of the time, that model can beat renting a GPU by the hour outright. If you want the machine itself, at a lower published rate on every shared card, packet.ai is the cheaper and more direct route.
Billing is hourly with monthly commits up to 20% off. There are no platform fees and no ingress charges; egress is $0.04/GB. Up to 2 TB of local NVMe per node is included. Dynamic instances are SSH-ready in under five minutes, Dedicated in five to ten. Capacity is live in the US (California, Virginia, Texas, Oregon) and Europe (Frankfurt, Amsterdam, Paris, London, Dublin). H100 SXM, H200 and RTX 5090 are on the notify list.
Against Modal, packet.ai is the lower per-hour cost and the higher ceiling on control. The same A100 80GB is $1.43/hr Dedicated against $2.50/hr on Modal; the B200 is $3.75/hr Dynamic against $6.25/hr. Modal's advantage is that you only pay while a request is running. packet.ai's is that when the GPU is running most of the time anyway, you pay 40–60% less for it.
packet.ai vs Modal at a glance
Published starting rates in USD per GPU-hour, on-demand unless noted. Percentages compare the first price in each cell.
| Category | packet.aiYOU | Modal |
|---|---|---|
| A100 80GB | $1.43/hr Dedicated−43% | $2.50/hr (per-second, GPU only) |
| B200 (180–192GB) | $3.75/hr Dynamic · $6.99/hr Dedicated−40% | $6.25/hr (per-second) |
| L40S (48GB) | $0.92/hr Dedicated | ~$1.95/hr (per-second) |
| RTX 6000 Pro (96GB) | $0.66/hr Dynamic | Not offered |
| RTX 4090 (24GB) | $0.39/hr Dedicated | Not offered |
| H100 (80GB) | Launching soon (notify list) | ~$3.95/hr (per-second) |
| Billing | Hourly | Per second, GPU + CPU + RAM metered separately |
| Idle cost | Full hourly rate while instance is up | Zero when scaled to zero; keep-warm costs extra |
| Deployment model | SSH instance, API, packet CLI; any runtime | Python functions and classes via modal deploy; containers built for you |
| Cold start | None once the instance is up | Seconds to tens of seconds; snapshots reduce it |
| Free tier | No credit card to start; usage-based | $30/month credit on starter plan |
| Best for | Sustained inference, training, fine-tuning, anything non-Python | Bursty Python inference, batch jobs, scheduled functions |
Detailed comparison
The break-even
Take an A100 80GB serving an internal model. On Modal it is $2.50 per GPU-hour but only for the seconds a request is executing. On packet.ai it is $1.43 for every hour the card is up. Ignoring Modal's separate CPU and memory metering, Modal is cheaper until the GPU is busy more than about 57% of the time; above that, packet.ai is cheaper, and at full utilisation it is 43% cheaper.
For the B200 the crossover is at roughly 60% utilisation ($3.75 divided by $6.25). Most production inference endpoints run well above that during business hours and well below it overnight, which is why a common pattern is packet.ai for the steady base load and a serverless layer for spikes.
Developer experience
Modal's SDK is the best in the category. You write Python, declare dependencies in code, and get autoscaling, web endpoints, cron schedules and volumes without touching infrastructure. Iteration is a redeploy away. For a team of Python developers shipping inference, that is a real productivity gain.
packet.ai gives you a box. You bring your own stack: vLLM, TGI, a custom CUDA extension, a Rust service, a Jupyter server, a Slurm node. The packet CLI and API handle provisioning, and the rest is yours. More setup, no ceiling.
What Modal cannot do
Modal has no persistent GPU you can log into, no non-Python runtime as a first-class citizen, and no consumer or workstation GPUs. If your workload is a multi-day training run, an interactive notebook, a game server, or anything that expects a long-lived machine, the serverless model fights you. packet.ai's Dedicated tier is built for exactly those long-lived jobs, with a 99% SLA.
What packet.ai cannot do (yet)
packet.ai does not scale to zero and does not bill per second. If your traffic is ten requests an hour with long gaps, you are paying for a lot of idle GPU. The Token Factory pay-per-token API is the answer for that shape of LLM traffic once it launches; for custom models with sporadic traffic, Modal-style serverless is the right tool today.
Who should choose which
Choose packet.ai if
- Your GPU is busy more than about 60% of the time and persistent billing is cheaper than per-execution pricing
- You need a long-lived instance for training, fine-tuning, notebooks or custom serving
- Your stack is not pure Python or needs kernel-level control over the environment
- You want RTX 6000 Pro or RTX 4090 - GPUs Modal does not offer
Choose Modal if
- Traffic is bursty and idle time dominates - scale-to-zero means you pay nothing when quiet
- Your team is Python-first and wants zero infrastructure to manage
- You need scale-to-zero web endpoints and scheduled functions out of the box
- You are prototyping and the $30/month free credit covers your early usage
Conclusion
Modal is the better tool for bursty, Python-native inference where idle time dominates. packet.ai is the better price for anything that keeps a GPU busy, and the only option of the two for long-lived instances and non-Python stacks. The crossover is around 60% utilisation; know your duty cycle and the choice is clear.
Same silicon. Smarter economics.
Every rate on this page is a published starting price you can deploy against today. Dynamic launches in under five minutes; no credit card to start.
Additional resources
- packet.ai GPU pricing: the full Dynamic, Dedicated and Clusters rate card.
- packet.ai documentation: API, CLI and platform guides.
- How intelligent scheduling works: why Dynamic keeps peak performance at a lower price.
- Clusters and wholesale quotes: multi-node InfiniBand capacity at ~30% below retail.
- Rent GPUs on packet.ai: specs, pricing and workload fit for every card.