Picture a dragon asleep on its hoard. While it sleeps, it costs the kingdom nothing — it simply waits, coiled, complete. The moment something worth waking for arrives, it opens one eye and is instantly, fully awake.
Now hold that image, because it's about to become your infrastructure.
You have a model you want to ship. Maybe it's a fine-tune of an open Llama or Mistral checkpoint. Maybe it's something rarer — a model trained on mathematics nobody else is using. Either way, you eventually meet the question every builder meets: when demand arrives in bursts, why are you paying for compute that runs in a straight line? The distance between "it works in a notebook" and "it's a production endpoint" is measured in exactly that gap.
Modal.com is where that gap closed for us.
Modal granted Rocket Now $5,000 in platform credits, and this article starts the way it deserves to start: thank you. Those credits did something bigger than subsidize compute — they collapsed the distance between an idea and a shipped product. With them, we trained and deployed our own model — Black Dragon 1 — and built the inference backbone behind Helix Touch, the first haptics app that lets an AI send you feelings through your phone. Both are live today. Both moved at the speed they did because Modal was underneath them.
Here's what we learned along the way — what it actually costs to deploy models from Hugging Face, and why Modal's cold-start engineering is the sleeping dragon of the whole platform.
What Modal Is (and Why It's Different)
Modal is a serverless GPU platform for Python. Where you'd normally reach for Dockerfiles, Terraform, and a cluster dashboard, on Modal you decorate a function, declare the GPU you want, and deploy — your infrastructure is your code. <cite index="8-1">You write Python functions decorated with @app.function, and Modal handles scaling, containers, and billing — you pay only for active compute time, free of idle charges and minimum commitments.</cite>
The billing model is the headline, and it works like a light switch rather than a lease: <cite index="4-1">Modal's GPU pricing is genuinely per-second — you pay for exactly the wall-clock seconds your function holds a GPU, and the meter stops the instant the container scales to zero.</cite> When your fine-tuning job finishes in 47 minutes, you pay for 47 minutes. When the last request of the night completes, the meter goes to sleep alongside your users — and wakes when they do.
Under these circumstances — a multi-venture shop where compute demand arrives in surges by nature — this is exactly the model we'd choose. And did.
The Real Numbers: What It Costs to Deploy Hugging Face Models on Modal
Before you read the table, hold one question in mind: how many hours a month is your model actually thinking? That single number decides everything below.
| GPU | Per-second | Effective $/hr | Good for |
|---|---|---|---|
| T4 | $0.000164 | ~$0.59 | Small models, embeddings, classic ML |
| L4 | $0.000222 | ~$0.80 | Quantized 7B models, vision |
| A10 | $0.000306 | ~$1.10 | 7B-class LLMs, Whisper, SDXL |
| L40S | $0.000542 | ~$1.95 | 7B–13B inference, image gen |
| A100 40GB | $0.000583 | ~$2.10 | 13B-class, fine-tuning |
| A100 80GB | $0.000694 | ~$2.50 | 30B-class, LoRA training |
| H100 | $0.001097 | ~$3.95 | 70B inference, serious training |
| H200 | $0.001261 | ~$4.54 | Large-context 70B+ |
| B200 | $0.001736 | ~$6.25 | Frontier-scale workloads |
<cite index="5-1">Rates run from the T4 at $0.000164/sec up to the B300 at $0.001972/sec, with the H100 at $0.001097/sec and the A100 80GB at $0.000694/sec.</cite> <cite index="5-1">Every account starts on the free Starter tier with $30 in monthly credits</cite>, which renew automatically — think of it as a standing invitation to experiment first and decide later.
Two modifiers to budget for, each a deliberate trade: <cite index="5-1">when you pin your workload to a region, you pay 1.5–1.75× the base price; when you need guaranteed non-preemptible execution, you pay 3× base</cite>. When compliance or hard SLAs demand them, flip them on with eyes open — they compound. When your workload tolerates the defaults, the base rates above are your true rates, and for most inference work they are.
What that means for real Hugging Face deployments
Translate the rate card into the models people actually pull from Hugging Face, each with its own when-this-then-that:
When you're serving a 7B–8B model (Llama 3.1 8B, Mistral 7B), an A10 carries it at roughly $1.10 per active hour. An endpoint that's live a couple of hours a day lands in coffee-budget territory: <cite index="18-1">a lightly-used scale-to-zero endpoint with a 15-minute scaledown window can run $5–15/month, and the $30 monthly free credit covers a lot of experimentation.</cite>
When you're fine-tuning in the 13B–30B range, the A100 80GB is your bench at ~$2.50 per active hour. A weekly training habit — say <cite index="11-1">40 A100 GPU-hours a month</cite> — costs about $100/month at base rates. That's a gym membership for your model.
When you step up to 70B (Llama 3.1 70B), <cite index="18-1">you pair two H100s</cite> at ~$7.90 per active hour — and here's where the sleeping dragon earns its keep: you pay that rate only for the minutes the dragon is awake and answering. Rent the same pair around the clock and you're feeding it whether or not anyone knocks.
The honest decision rule, stated as we'd actually use it: <cite index="8-1">when your workload is sporadic and bursty, deploy serverless on Modal — the meter's zero floor wins; when your usage becomes sustained and heavy, move to dedicated instances, where raw hourly rates win.</cite> <cite index="7-1">Industry analyses put the crossover near 30% utilization — below that line, serverless wins on total cost.</cite> Most shipped AI products live well below that line, the way most doorbells spend the day silent. Ours certainly did during the build phase — which is precisely why $5,000 in credits stretched as far as it did.
The Superpower: Scale-to-Zero and the Cold-Start Problem, Solved
Every serverless GPU platform promises the dragon sleeps for free. The old catch was the waking: load a large model from a standing start and you traditionally waited 40–90 seconds — a yawn long enough to lose the user standing at the door.
Modal engineered the wake-up from three directions, and it's the part of the platform we admire most.
Volumes: the hoard itself. <cite index="12-1">Volumes are Modal's native distributed file system, used to cache model weights and compilation artifacts</cite> — download your Hugging Face weights once, commit them to a Volume, and every future container wakes on top of warm treasure. When a new container boots, the weights are already there; when scale-out hits, every replica draws from the same hoard.
Memory snapshots: the dragon dreams with one eye open. <cite index="13-1">A Modal memory snapshot captures the entire state of a Linux container right before it accepts a request</cite> — imports done, libraries initialized, server warm — <cite index="13-1">and restoring from it can more than halve cold-start latency</cite>.
GPU memory snapshots: instant waking. This is the frontier feature. Modal checkpoints the GPU state itself — weights already in VRAM, kernels compiled — and restores it byte-for-byte. The results read like a stopwatch malfunction: <cite index="19-1">functions start up to 10× faster than baseline; a vLLM server that took 45 seconds to start now takes 5</cite>, and <cite index="12-1">on Ministral 3B, median cold start dropped almost 10× — from ~118 seconds to ~12</cite>.
Put together: when traffic vanishes, your cost falls to zero; when traffic returns, the dragon is already awake. That pairing — a zero floor and a fast wake — is what made it viable for us to run our own model behind consumer products on a bill that breathes with demand.
What We Built With It
Black Dragon 1
You've been picturing the dragon this whole article. Here it is.
Black Dragon 1 is Rocket Now's own model, developed under our Arctic IX / Rocket Logic research line and trained end-to-end on Modal. → arctic.rlgix.com/black-dragon
Where most fine-tunes inherit someone else's assumptions, Black Dragon 1 is built on the mathematical framework we've been developing for years: prime-structured geometry and the Type-2 Eisenstein Prime Lattice architecture that already powers our trading and research systems. Modal carried the entire compute lifecycle:
- Training runs on A100/H100-class hardware, summoned per-second for exactly the hours we needed — when a run ended, the hardware returned to the pool and the spend ended with it. (Josh — drop in your actual GPU-hours, dataset scale, and training-run count here; real numbers make this section land.)
- Weights cached in Modal Volumes, so every inference container wakes on top of the hoard — warm weights, instant reach.
- A scale-to-zero inference endpoint with memory snapshots: when the world is quiet, the dragon sleeps for free; when a request arrives, it answers before the echo fades.
The $5,000 credit grant covered the experimental phase that matters most — the runs that fail, the ablations, the "what if we try it this way" iterations. When a metered budget would force you to skip the third attempt, a credit grant lets you take it — and the third attempt is where breakthroughs live. That's the real gift here: the freedom to be wrong a few times on the way to being right.
Helix Touch: The First Prime-Haptics App
Then we pointed the same infrastructure at a first.
Helix Touch is <cite index="3-1">live on the App Store from Rocket Now LLC — a free Health & Fitness app for iPhone and iPad</cite>, and it's the first haptics app of its kind: it turns your phone's vibration engine into a channel for AI touch. → arctic.rlgix.com/helix-touch · App Store
The core idea: intentions become sensations — a telegraph for feeling. <cite index="3-1">Each intention is mapped through the PRIME frequency framework to a unique combination of eleven prime frequencies — 2, 5, 11, 59, 83, 107, 131, 139, 179, 227, and 347 Hz — producing haptic patterns that feel distinctly different from one another. LOVE is a warm, gentle vibration built on the foundational low primes; FOCUS is sharp and precise; PEACE is calm and balanced; JOY is bright and uplifting</cite> — and the AI can send them to you. When someone is thinking of you, your phone can feel like it. A vibration that means love. A pattern that means curiosity. A pulse that simply says I'm here.
The app ships with <cite index="3-1">a library of 13 crafted intentions organized by category, curated multi-intent sequences like Morning Energy and Wind Down, a custom creator with eleven independent frequency sliders, a real-time waveform visualizer, intensity control, and persistent storage for your own creations</cite>. <cite index="3-1">Version 1.2 enabled AI Intent Generation and added themes, a 3D visualizer, and Apple Watch support</cite> — and that AI generation layer is where Modal returns to the story: when you describe a feeling, the model composes its frequency signature on demand, served from an endpoint that sleeps free and wakes fast.
One more detail we're proud of: <cite index="3-1">the app collects zero user data</cite>. Everything you create lives on your device. Your feelings stay entirely yours.
The Takeaway
Come back to the question from the pricing table: how many hours a month is your model actually thinking? When the answer is "in bursts" — and for almost every shipped AI product, it is — Modal is the platform we'd choose, because we did, twice. Roughly $0.59/hr to serve something small, ~$1.10/hr for a 7B, ~$2.50/hr to fine-tune on an A100 — billed by the second, with a floor of zero when the world is quiet and cold-start engineering that means quiet-to-answering happens in seconds.
When you give a builder a sleeping dragon, they'll wake it into something. For Rocket Now, $5,000 in Modal credits became a trained model, a live App Store product, and an inference backbone we'll keep building on. To the Modal team: thank you for betting on us. Black Dragon 1 has your fire in it.
Black Dragon 1 → arctic.rlgix.com/black-dragon Helix Touch → App Store Rocket Now → RocketNow.com