doubleAI’s New Model 2026: Can It Really Cut Your Compute Bill?

The doubleAI model launched today, and it targets the biggest cost for most teams running AI products: compute. doubleAI is a Tel Aviv startup backed by Nvidia and led by Mobileye co-founder Amnon Shashua. Its new model, Maxwell, doesn’t generate text or images. It rewrites the machine code of programs while they run so they use less hardware. The timing matters because GPU rental prices keep climbing and inference is often a team’s largest line item. A credible tool that cuts that bill without code changes deserves a close look.

What’s actually new with the doubleAI model

doubleAI calls Maxwell a “code execution model” (CEM) and says it is the first of its kind. Most AI developer tools help you write code. Maxwell works on the compiled machine code of a program that is already running, on both CPUs and GPUs. It tunes that code for the hardware it runs on and for the data patterns it actually sees. Your source code stays untouched. According to The Next Web, Maxwell formally proves that each change preserves the program’s behavior. If runtime conditions shift, guards switch back to the original code.

All the numbers so far come from the company, and no one has independently checked them. doubleAI says one early customer cut compute spending by 67%. It also reports that data pipelines ran more than 38x faster and AI inference kernels more than 4.5x faster on real workloads. LTX, which builds open-weight multimodal models, reportedly doubled its model inference speed. The pricing is unusual: doubleAI plans to charge a share of the savings it produces instead of a license or per-seat fee. If your compute bill falls from $10 million to $6 million, doubleAI takes a cut of the $4 million difference. It hasn’t said how big that cut is.

The company is well funded. doubleAI has raised $220 million in total, including a $200 million Series A co-led by Lightspeed and Bessemer, with Nvidia and Dell Technologies Capital also investing. It is valued at over $1 billion. According to FourWeekMBA, roughly half of that funding went to about 1,000 Nvidia B300 chips. Maxwell is available now through early access on doubleAI’s website.

Why it matters

• It attacks costs at the source. Most ways to cut AI compute costs mean negotiating GPU contracts, switching to a smaller model, or hiring kernel engineers. Maxwell targets inefficient code, and almost every production stack has some.
• Hardware prices aren’t falling soon. One-year contract prices for renting Nvidia H100 capacity are up about 60% year over year. The more rented compute costs, the more it’s worth to get extra work out of the same GPUs.
• Gain-share pricing lowers the risk of trying it. If Maxwell saves nothing, you should owe little or nothing. Few infrastructure vendors price that way.
• It applies beyond LLMs. The 38x figure for data pipelines may matter more to many business owners than the inference numbers. ETL, analytics, and preprocessing jobs quietly consume a lot of compute.
• The correctness guarantee is the real selling point. Aggressive performance work tends to break things. If formal verification holds up in production, GPU efficiency stops being a risky project and becomes a setting you turn on.
• Small teams get optimization they couldn’t otherwise afford. GPU efficiency has usually meant paying for scarce CUDA experts. Automating that work gives smaller teams a capability once limited to hyperscalers.

How to use it today

Maxwell is in early access, and doubleAI hasn’t published a public API or SDK. Be skeptical of any tutorial claiming otherwise. You can prepare now. Under gain-share pricing, your bill depends on savings measured against your baseline. Teams with clean baseline numbers will negotiate better terms and spot inflated claims.

1. Measure your current GPU utilization. Low utilization means you’re paying for idle hardware, which is a different problem from slow code. Run this on each inference node during a typical busy hour:

   nvidia-smi --query-gpu=timestamp,name,utilization.gpu,utilization.memory,memory.used,power.draw \
     --format=csv -l 10 > gpu_baseline.csv

2. Calculate your true cost per unit of work. Gain-share contracts work best when savings tie to a business unit, such as cost per 1,000 requests or per pipeline run, rather than raw GPU hours. A simple calculator:

   # cost_baseline.py  (run with: py cost_baseline.py)
   gpu_hourly_rate = 2.85      # your contracted $/GPU-hour
   gpus = 8
   hours_per_month = 730
   requests_per_month = 42_000_000
   
   monthly_cost = gpu_hourly_rate * gpus * hours_per_month
   cost_per_1k = monthly_cost / (requests_per_month / 1000)
   print(f"Monthly GPU spend: ${monthly_cost:,.0f}")
   print(f"Cost per 1K requests: ${cost_per_1k:.4f}")

3. Profile your heaviest workload. Find where the time goes before anyone else optimizes it, so you have a before-and-after comparison. For PyTorch inference:

   import torch
   from torch.profiler import profile, ProfilerActivity
   
   with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA]) as prof:
       model(batch)   # your representative inference call
   
   print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=15))

4. Take the free wins first. If you still serve models with plain Hugging Face pipelines, an open-source engine like vLLM can cut inference costs before you pay anyone a share of savings. It also gives you a fairer baseline:

   pip install vllm
   vllm serve meta-llama/Llama-3.1-8B-Instruct --gpu-memory-utilization 0.90 --max-num-seqs 256

5. Apply for early access with a specific workload in mind. Pick one job that is expensive, easy to measure, and not customer-facing, such as a nightly batch pipeline or an internal embedding job. Paste this into your request or first call:

   Workload: [nightly feature pipeline / LLM inference service]
   Hardware: [e.g., 8x H100, AWS p5]
   Current monthly compute spend: $[X]
   Baseline metric: $[Y] per [1K requests / pipeline run], [Z]% avg GPU utilization
   Questions:
   1. What share of verified savings do you charge, and for how long?
   2. How is the savings baseline measured and who audits it?
   3. What happens to pricing if our workload or hardware changes?
   4. Can we run a time-boxed pilot on one non-critical workload first?
   5. What telemetry or code access does Maxwell require?

6. Lock the baseline into the contract before the pilot starts. In a gain-share deal, everything depends on how “savings” is defined. Agree in writing whether you measure savings per request, per job, or per GPU-hour, and whether savings you’d have gotten anyway, such as from newer hardware, are excluded.

How it compares

Nothing on the market does exactly what Maxwell claims: runtime machine-code optimization, with formal verification, on both CPU and GPU. But it competes for the same budget as several established ways to make LLM inference cheaper.

Approach	Where it optimizes	Code changes needed	Pricing	Best for
doubleAI Maxwell	Machine code at runtime, CPU and GPU	None claimed	Share of verified savings	Large, steady compute bills across mixed workloads
vLLM / SGLang	LLM serving (batching, KV cache)	Swap serving layer	Free, open source	Teams self-hosting open-weight models
Nvidia TensorRT-LLM	Model compilation for Nvidia GPUs	Model conversion and build step	Free, open source	Nvidia-only shops chasing peak throughput
torch.compile	PyTorch graph and kernel fusion	One-line wrapper, some debugging	Free	PyTorch teams wanting quick wins
Managed inference APIs	Provider handles everything	Rewrite to provider API	Per token	Small teams without GPU ops staff

Our take: these approaches stack. Use the free tools first because they cost nothing. Maxwell’s pitch is that it finds savings after you’ve done the obvious work, and that is where its gain-share pricing will either justify itself or fail to.

What’s next

The next few months come down to independent proof. Every headline number so far, including 67%, 38x, and 4.5x, comes from doubleAI or its early customers. Look for third-party benchmarks, named case studies with before-and-after bills, and published terms for the savings share. A 20% share looks very different from a 50% share, and doubleAI hasn’t said where it lands.

Also watch how Maxwell handles changing workloads. Runtime optimization tunes for the code paths and data patterns a program actually sees. The company says guards revert to the original code when conditions change, but frequent reverts would shrink real-world savings relative to steady-state benchmarks. Teams that ship model updates weekly should ask how quickly Maxwell re-optimizes after each deploy.

Finally, watch the Nvidia relationship. Nvidia is an investor, and doubleAI runs on a large B300 cluster. A tool that gets more work out of each GPU could in theory reduce GPU demand. In practice, cheaper inference usually drives more AI usage. doubleAI is betting that cheaper inference means more workloads, not fewer chips. If that bet pays off, savings-based pricing could become standard across AI infrastructure.

Frequently Asked Questions

What is the doubleAI model called, and what does it do?

It’s called Maxwell, and doubleAI describes it as a “code execution model.” It rewrites the machine code of running software on CPUs and GPUs to reduce compute use without changing your source code. The company says it formally verifies that each change preserves the program’s behavior.

How much can doubleAI actually reduce AI compute costs?

doubleAI reports one early customer saving 67%, data pipelines running more than 38x faster, and inference kernels running more than 4.5x faster. No one has independently verified these figures. Treat them as best cases and run your own pilot against a clean baseline.

How does doubleAI charge?

It plans to take a share of the compute savings it delivers instead of charging a flat license fee. The exact percentage isn’t public, so ask about it first in any early access conversation.

Can I sign up for doubleAI Maxwell today?

Early access is open through doubleAI’s website. There’s no public self-serve API yet. Expect a sales-led pilot, most likely aimed at companies with large, recurring compute bills.

Is Maxwell worth it for a small business?

Probably not yet if you spend a few hundred dollars a month on a managed API. Your provider controls that infrastructure, and model choice and prompt length matter more. If you self-host models or run heavy data pipelines with five-figure monthly GPU bills, apply.

Should I stop using vLLM or TensorRT-LLM if I try Maxwell?

No. Those tools are free and handle well-understood serving optimizations. Use them first to set a strong baseline. Maxwell’s claimed value lies in the savings left after that, so judge it on that number.