RunPod vs Modal vs RightNow: Serverless GPU Guide 2026
In short: RunPod is the raw-compute pick: published per-second prices per GPU (H100 at $4.55/hour serverless), a template marketplace, and the strongest documented compliance set. Modal is the developer-experience pick: Python-native, GPU memory snapshots for fast cold starts, and a free Starter tier with $30/month in credits. RightNow's RunInfra, from a two-person YC-backed lab, flips the model: no GPU picking at all, per-token billing behind an OpenAI-compatible API, from $50/month. Different abstractions, honest trade-offs; no absolute winner.
Comparison at a glance
| RunPod | Modal | RightNow (RunInfra) | |
|---|---|---|---|
| Best for | Raw GPU price/performance | Python-native developer experience | Per-token managed inference |
| Billing model | Per second of GPU time | Per second + monthly credits | Per token + monthly commitment |
| Entry point | $0.69/hr (L4, serverless) | $0 + usage ($30 credits/month) | $10 free credit; Core from $50/month |
| H100 rate | $4.55/hr serverless | ≈$3.95/hr equivalent | n/a (per-token pricing) |
| Scale to zero | Yes | Yes | Yes |
| SOC 2 | Type 2 + SOC 3 | Type II | Enterprise plan only |
| GDPR | Yes (documented) | Not confirmed | Not confirmed |
| Public reviews | G2 + Trustpilot (mixed) | Thin (Capterra, PH) | None for RunInfra yet |

One clarification before anything else, because it genuinely confused our research: the brand RightNow ships two different products. The RightNow AI CUDA editor is a code-editing and profiling tool; RunInfra is the serverless inference platform, and that is what belongs in this comparison. Everywhere below, RightNow's pricing and features refer to RunInfra unless we say otherwise. Everything was verified on vendor sites and review platforms on July 24, 2026, per our editorial policy.
What is RunPod?
RunPod sells GPU compute with unusual price transparency: a public per-second price list covering serverless endpoints (L4 at $0.69/hour equivalent up to B300 at $9.98/hour), dedicated pods on Community or Secure Cloud, and multi-GPU Instant Clusters. Serverless endpoints scale to zero, so you pay only while requests run. A community template marketplace and Hugging Face model import lower the setup work for common stacks.
RunPod also has the strongest documented trust posture here: SOC 2 Type 2 plus SOC 3, an explicit GDPR claim on its compliance page, a public trust center, and active release notes. Its review record is the largest of the three and genuinely mixed; the praise centers on accessibility and templates, while the sharpest criticism targets support responsiveness, including one high-spend customer's account of being ignored. Both sides are quoted below.
What is Modal?
Modal approaches serverless GPUs from the developer's side: you write Python, decorate functions, and Modal handles containers, scaling and GPUs. Its published engineering work on GPU memory snapshots targets one of the category's core pains, slow cold starts, and its per-second compute rates are competitive: roughly $0.59/hour equivalent for a T4 up to $6.25/hour for a B200, with region selection and guaranteed execution as priced multipliers.
The commercial model is credits plus usage: Starter is free with $30/month in compute credits, Team is $250/month with $100 in credits and higher concurrency, Enterprise is custom. Modal is SOC 2 Type II compliant per its blog, though its security docs do not explicitly confirm GDPR, and SSO appears in those docs only for Modal's own internal access, not as a confirmed customer feature. Its public review base is thin; the quotes below reflect what exists, not necessarily the sentiment of its full customer base.
What is RightNow (RunInfra)?
RightNow AI is a YC-backed GPU research lab; RunInfra is its serverless inference product, described on its own site as chat-native model optimization and infrastructure. The abstraction level is the differentiator: instead of renting GPU time, you deploy a model (including Hugging Face imports, with AWQ/GPTQ/FP8 quantization) and pay per token through an OpenAI-compatible API. Small 1-8B models run at $0.08 per million input tokens and $0.20 per million output tokens, scaling up to $0.80/$2.50 for 70B+ models.
Commercially, RunInfra starts with a $10 free credit, then a Core plan with a custom monthly commitment between $50 and $1,000 (with a 99.9% SLA), and an Enterprise tier above $1,000/month that adds B200/H200 access, self-hosted deployment, audit logs and SOC 2 Type II. The honest caveats: there are no third-party reviews of RunInfra anywhere we could find, several capabilities (multi-region, Docker support, Python SDK) are simply not documented publicly, and compliance below Enterprise is unstated. It is the youngest and least verifiable product in this comparison, and we treat it that way.
Pros and cons
RunPod
Pros
- The most transparent pricing in the category. A public per-second price list across a dozen GPU types, from $0.69/hour, with serverless, pods and clusters all published.
- Documented compliance. SOC 2 Type 2, SOC 3 and an explicit GDPR claim, plus a public trust center; no rival here matches that paper trail.
- Templates lower the barrier. Reviewers single out the template marketplace and UI as the easy on-ramp for people without their own hardware.
Cons
- Support is the recurring complaint. The harshest review we found came from a customer reporting roughly $600k of spend and unanswered messages; weigh that if you expect hands-on help.
- You still manage the stack. Containers, endpoints and GPU choices are yours to configure; it is compute, not a managed inference product.
- No published customer SSO/SAML. The trust center does not mention it, which enterprise security reviews will notice.
Modal
Pros
- Best developer experience claim in the set. Python-native functions instead of infrastructure files, praised in reviews for speeding up internal tooling work.
- Engineering aimed at cold starts. GPU memory snapshotting for sub-second startup is documented publicly, addressing the classic serverless GPU weakness.
- Gentle entry. Free Starter plan with $30/month in credits makes real experiments possible before any commitment.
Cons
- Less infrastructure control. The one substantive critical review notes restrictions on fine-grained customization compared with traditional clouds; the abstraction cuts both ways.
- GDPR not explicitly confirmed. The security docs cover SOC 2 Type II but are silent on GDPR, which European buyers must chase up themselves.
- Very thin review base. A handful of reviews across platforms means limited independent evidence for a production bet.
RightNow (RunInfra)
Pros
- Per-token billing eliminates idle-GPU math. For spiky traffic, paying $0.08-$2.50 per million tokens instead of per GPU-hour can be structurally cheaper, and scale-to- zero is inherent to the model.
- OpenAI-compatible API is explicit. Unlike both rivals, RunInfra states this directly on its plans page, making migration from hosted APIs straightforward.
- Optimization is the pedigree. The parent lab's focus on CUDA profiling and quantization (AWQ/GPTQ/FP8 included on Core) is exactly the discipline inference serving rewards.
Cons
- Zero independent reviews of RunInfra. The only public quotes about the brand concern the separate CUDA editor product; the inference platform itself has no third-party track record we could verify.
- Compliance is gated high. SOC 2 Type II arrives only on Enterprise, above a $1,000/month commitment; Core buyers get a 99.9% SLA but no attestation.
- Public documentation has holes. Multi-region, custom containers and SDK support are undocumented; you will need answers from the founders, not the docs.
Which platform fits which team?
You want maximum GPU for minimum money, and you can run your own stack. RunPod. The published per-second prices are the benchmark the category gets measured against, and scale-to-zero serverless keeps idle cost at zero.
Your team thinks in Python and ships fast. Modal. The function-decorator model plus snapshot-accelerated cold starts is built for ML engineers who do not want to touch infrastructure files, and the free credits make trying it a no-brainer.
You serve open-weight LLMs and traffic is unpredictable. Consider RunInfra: per-token pricing means a quiet day costs almost nothing, and the OpenAI-compatible API keeps you portable. Contain the bet: use the $10 credit and a Core commitment you can afford to walk away from, given the missing reviews and gated compliance.
You need enterprise compliance today. RunPod on documentation, full stop. Modal follows with SOC 2 Type II; RunInfra requires its Enterprise tier for the same claim.

Pricing
A structural note that applies to all three: none offers annual billing. RunPod and Modal are pure usage models, RunInfra is a monthly commitment; comparisons with annually billed platforms should account for that.
RunPod pricing
Everything is published and billed per second. Serverless (active usage only, scale-to-zero): L4 $0.69/hour, RTX 4090 $1.10/hour, A100 80GB $2.72/hour, H100 80GB $4.55/hour, B300 $9.98/hour. Dedicated pods: H100 PCIe from $1.99/hour on Community Cloud and $2.89/hour on Secure Cloud. Instant Clusters start at $1.79/hour per A100 SXM, with enterprise options via sales. This is a representative subset; the full per-GPU matrix is on the pricing page. Pricing verified on July 24, 2026.
Modal pricing
Starter: $0/month plus usage, with $30/month in included credits, 3 seats and 10-GPU concurrency. Team: $250/month plus usage, with $100/month in credits and 50-GPU concurrency. Enterprise: custom. Compute runs per second: T4 at $0.000164/s (≈$0.59/hour), A100 80GB at $0.000694/s (≈$2.50/hour), H100 at $0.001097/s (≈$3.95/hour), B200 at $0.001736/s (≈$6.25/hour); region choice adds a 1.5-1.75x multiplier and guaranteed non-preemptible execution 3x. Pricing verified on July 24, 2026.
RightNow (RunInfra) pricing
$10 one-time free credit without a card. Core: a custom monthly commitment between $50 and $1,000 (1 credit = $1), including T4-H100 GPUs, quantization, scale-to-zero, the OpenAI-compatible API and a 99.9% SLA; inference is billed per token from the credit balance ($0.08/$0.20 per million input/output tokens for 1-8B models up to $0.80/$2.50 for 70B+). Enterprise: custom above $1,000/month, adding B200/H200, self-hosting, audit logs, up to 99.99% SLA and SOC 2 Type II. The separate CUDA editor product has its own Free and $20/user/month Pro plans. Pricing verified on July 24, 2026.

What users say
Full disclosure on the evidence base: RunPod has a real review footprint on G2 and Trustpilot; Modal's is thin; and for RunInfra there are no third-party reviews at all. The only public quotes about the RightNow brand concern its separate CUDA editor, so we do not present them as reviews of the inference platform; we quote nothing for RunInfra rather than borrow praise from a different product. We publish at least one critical quote per two positive ones wherever quotes exist.
RunPod
"RunPod is the best way to experiment and learn on this topic if you do not own high-end hardware." - G2 reviewer, via G2
"I also really love how they've integrated certain templates, with a user-friendly UI/UX." - G2 reviewer, via G2
"0 customer support = 1 star, spent around 600k USD and the support still completely ignoring my messages." - Trustpilot reviewer, high-spend customer, via Trustpilot
Modal
"Modal turned out to be a good tool as it sped up the development of our internal tools" - Matthew H., Business Analyst, via Capterra
"Serverless GPU infrastructure helps us scale to workloads of hundreds of H200s/B200s within seconds to maintain low latency for our retrieval models in a cost-effective way." - Eitan Borgnia, creator of Relace Repos, via Product Hunt
"One minor issue we faced was some restrictions regarding fine grained infrastructure customization across modal compared to traditional cloud providers" - Matthew H., Business Analyst, via Capterra
RightNow (RunInfra)
No reviews of the inference platform exist yet on any platform we checked (G2, Capterra, Trustpilot, Product Hunt, Reddit). That is stated plainly rather than papered over.

Cold starts and scale-to-zero, compared
Scale-to-zero is the promise that makes serverless GPUs economical, and all three platforms deliver it: idle endpoints cost nothing. The catch is always the wake-up. A model that scaled to zero has to load back onto a GPU before the first request returns, and that cold-start latency is where serverless platforms differentiate or disappoint.
Modal is the only one of the three with a publicly documented engineering answer: GPU memory snapshotting, which restores a warmed model image for sub-second startup according to its own write-up. RunPod's serverless endpoints bill per second of active usage, which bounds the cost of cold starts but does not document a comparable snapshot mechanism. For RunInfra the question dissolves partially: because you buy tokens rather than GPU time, wake-up mechanics are the vendor's problem, though with no public documentation of how it handles them, latency-sensitive buyers should test with the free credit before committing. If p95 latency on infrequent traffic matters to you, benchmark all three with your actual model; vendor claims here are directional, not guarantees.
The SSO blind spot
One finding surprised us enough to flag separately: none of the three platforms clearly documents customer-facing SSO/SAML. RunPod's trust center does not mention it, Modal's security docs reference SSO only for its own employees' internal access, and RunInfra's plan pages are silent. For a category selling to enterprises running proprietary models, that is a collective gap; put it on your vendor questionnaire, because the public documentation will not answer it.
Three billing models, one decision
Strip away the features and this comparison is really about three ways to buy the same silicon. RunPod prices the hardware: you know exactly what an H100-hour costs, and efficiency is your job. Modal prices the runtime: still per second, but wrapped in a developer experience designed to make efficient use the default. RunInfra prices the outcome: tokens in, tokens out, and GPU utilization becomes the vendor's problem. The right choice tracks your workload shape: steady high-volume serving rewards owning the efficiency work on RunPod's rates; bursty internal tooling suits Modal's credits; spiky open-model APIs fit per-token billing, if you can accept RunInfra's youth. The billing model, more than any feature, is the real decision.
Verdict: choose by billing model and evidence
RunPod earns the default for cost-driven production teams: transparent prices, documented compliance, real reviews, with support quality as the known risk to manage. Modal is the pick when engineering velocity beats infrastructure control, especially for Python-centric teams; verify GDPR yourself if that matters. RunInfra is the interesting outsider: the per-token abstraction is genuinely differentiated, but with no independent track record and compliance locked behind Enterprise, size your commitment to what you can afford to lose. Our browser infrastructure comparison shows the same pattern in a neighboring category: incumbents sell transparency, newcomers sell abstraction.
Recap
| RunPod | Modal | RightNow (RunInfra) | |
|---|---|---|---|
| Pricing | Per-second GPU rates, published | $0/$250 tiers + per-second usage | $50-$1,000/month commitment, per-token |
| Target buyer | Cost-driven ML teams | Python-first product teams | Spiky open-model API workloads |
| Key differentiator | Price transparency + compliance | DX + GPU memory snapshots | Per-token billing, OpenAI-compatible |
Browse more serverless GPU comparisons, read how we make money - vendors never buy rankings or scores here - or report a correction if you spot something off. GPU pricing changes fast; our verification dates tell you exactly when we last checked.
Frequently asked questions
What is the best serverless GPU platform for AI inference?
It depends on how you want to pay and build. RunPod sells raw GPU time at published per-second rates (an H100 at $4.55/hour serverless) with a template marketplace. Modal wraps GPUs in a Python-native developer experience with $30/month of free credits to start. RightNow's RunInfra abstracts GPUs away entirely and bills per token, from a $50/month commitment. All three scale to zero.
How much does RunPod cost?
RunPod publishes per-second GPU pricing: serverless rates range from $0.69/hour for an L4 to $4.55/hour for an H100 and $9.98/hour for a B300, billed only while your workload runs. Dedicated pods start lower, with an H100 PCIe at $1.99/hour on Community Cloud. Verified on the vendor's pricing page on July 24, 2026.
Is Modal free to start?
Effectively yes: Modal's Starter plan has no subscription fee and includes $30/month of compute credits, up to 3 seats and 10 concurrent GPUs. Beyond the credits you pay per second of compute, for example about $3.95/hour equivalent for an H100. The Team plan at $250/month adds $100 in credits and higher limits.
What is RightNow AI and what is RunInfra?
RightNow AI is a YC-backed GPU research lab with two distinct products: a CUDA code editor for profiling and optimizing GPU code, and RunInfra, its serverless inference platform. RunInfra is the product that competes with RunPod and Modal: it hosts models behind an OpenAI-compatible API and bills per token rather than per GPU-second.
Which serverless GPU platform has the best compliance story?
RunPod documents the most: SOC 2 Type 2 plus SOC 3, an explicit GDPR claim and a public trust center. Modal is SOC 2 Type II compliant but does not explicitly confirm GDPR in its security docs. RunInfra offers SOC 2 Type II only on its Enterprise plan, above a $1,000/month commitment. None of the three clearly documents customer-facing SSO/SAML.
What is the cheapest way to run LLM inference without managing GPUs?
If your model is small and traffic is spiky, RunInfra's per-token model can be cheapest: $0.08 per million input tokens for 1-8B models, with no idle GPU cost and a $10 free credit to test. If you need control of the runtime, RunPod's L4 at $0.69/hour is the lowest published per-hour entry point in this comparison. Do the math on your actual traffic pattern; the billing models differ more than the GPUs do.
Comments
No comments yet.