TL;DR: Ollama raised a $65M Series B on July 9, 2026, led by Theory Ventures, and its stated roadmap — better AMD ROCm, Windows ARM inference, smarter multi-GPU scheduling — makes an AMD home-lab build materially less risky than it was a year ago. Nothing breaks today: the license is still MIT. But VC money eventually wants returns, so keep your stack portable.

	Buy AMD now	Wait for the roadmap	Stay on NVIDIA
Best for	20–24GB VRAM per dollar	Risk-averse AMD buyers	Max tokens/sec, least friction
Cost today	Used RX 7900 XT 20GB ~$535–$600; RX 9070 XT 16GB ~$598–$689	$0 now	Used RTX 3090 24GB ~$1,050–$1,254
The catch	ROCm still ~20–25% slower than CUDA	ROCm 7.2 already reached parity — you’re waiting on polish, not capability	Highest price per GB of VRAM

Honest take: The funding is good news for AMD owners specifically — ROCm support is now a committed budget line at a VC-backed company, not a community side project. If you want cheap 20GB+ VRAM, a used RX 7900 XT is a better local-LLM buy than the newer RX 9070 XT. But treat Ollama’s MIT license as “true today,” not “true forever,” and don’t build anything you can’t move to llama.cpp in an afternoon.

What Ollama actually raised

On July 9, 2026, Ollama announced a $65 million Series B led by Theory Ventures, bringing total funding to $88 million. Participating investors include Benchmark, 8VC, Y Combinator, Pace Capital, 49 Palms, and GTMFund. (If you saw an earlier rumor naming Sequoia or “Infrastructure Ventures” as the lead — that was wrong; Theory Ventures led the round.)

The growth numbers are the real story. Ollama now serves 8.9 million developers per month, roughly double its January 2026 figure, and is adding close to one million new installs per week. Monthly model downloads hit 52 million by Q1 2026 — a 520× jump from about 100,000 in Q1 2023. The GitHub repo sits near 174,000 stars with ~16,500 forks, one of the top two Go projects on the platform by stars. All of this is run by a team of 14 people, and Ollama is reportedly in use inside 85% of the Fortune 500, including regulated sectors like government, healthcare, and finance.

That last point is why the money showed up. A CLI that installs a local model in two minutes has quietly become infrastructure. For a deeper look at why local models got good enough to justify that adoption, see why local LLMs got good in 2026.

Why does a model runner need $65M?

Ollama’s public roadmap names four priorities, and three of them map directly onto home-lab hardware decisions:

1. Improved AMD ROCm support
2. Windows ARM native inference
3. Better multi-GPU scheduling
4. Enterprise security controls (the part that pays the bills)

The fourth item explains the round — enterprise features are how a free open-source tool converts 8.9 million users into revenue. The first three are what you actually get out of it as a home labber. Let’s take them in order of how much they change your buying math.

AMD ROCm: what the money actually changes

Here’s the part AMD-curious builders should read twice. The heavy lifting already happened before this funding round: ROCm 7.2, released in March 2026, was the first AMD software release to reach Ollama, LM Studio, llama.cpp, and vLLM parity with CUDA out of the box. Before that, getting an AMD card running local inference meant hunting for the right HSA_OVERRIDE_GFX_VERSION, matching driver and ROCm versions by hand, and accepting that half the tutorials assumed CUDA.

Ollama now requires the ROCm v7 / HIP 7 driver stack on both Linux and Windows, and — importantly — Windows AMD support is officially supported, not a preview. The full setup path is covered in our ROCm 7.2 on Ubuntu guide.

So what does $65M add? Not capability — polish and coverage. Expect faster onboarding of new AMD architectures, fewer GFX-version edge cases, and real benchmark parity data instead of forum anecdotes. The signal matters more than any single feature: ROCm is now a funded roadmap item at a company with 14 employees and Fortune 500 obligations, not a best-effort community port. That changes the risk calculus for buying an AMD GPU today.

The performance gap, in real numbers

Be honest with yourself about the tradeoff. ROCm’s HIP translation layer, less-optimized kernel dispatch, and fewer hand-tuned quantization kernels still add roughly 20–25% latency versus equivalent CUDA workloads. In practice:

• RX 7900 XTX (24GB) runs Llama 3.1 8B Q4 at roughly 66–96 tok/s depending on the setup and reviewer.
• A used RTX 3090 (24GB) hits about 87 tok/s on the same test — and it’s the more mature CUDA path.

Decode speed on local LLMs is memory-bandwidth-bound, not compute-bound, so the raw bandwidth number tells you most of the story. The RTX 3090’s 936 GB/s still edges out AMD’s best consumer cards, and CUDA’s software maturity closes the rest of the gap. If you want the absolute most tokens per second per dollar under 24GB, the used RTX 3090 is still the value king at ~$1,050–$1,254.

But AMD wins on VRAM per dollar, and that’s the whole reason to consider it.

The RX 9070 XT bandwidth trap

This is the single most useful thing in this article, so don’t skim it: for local LLM inference, the older RX 7900 XT is a better buy than the newer RX 9070 XT.

GPU	VRAM	Bandwidth	MSRP	Street (Jul 2026)
RX 9070 XT	16GB GDDR6	640 GB/s	$599	~$598 used / ~$689 new
RX 7900 XT	20GB GDDR6	800 GB/s	$899	~$535–$600 used
RX 7900 XTX	24GB GDDR6	960 GB/s	$999	~$820 used

The RX 9070 XT is the newer RDNA 4 card, and for gaming it’s excellent. But it ships with a 256-bit bus and 20 Gbps GDDR6, giving it 640 GB/s — a full 160 GB/s less bandwidth than the two-generation-older RX 7900 XT, plus 4GB less VRAM. For a bandwidth-bound workload like LLM decode, “newer” loses. A used RX 7900 XT at ~$535–$600 gives you 20GB and 800 GB/s for less money than a new 9070 XT. If you’re weighing the 9070 XT against NVIDIA’s mid-range instead, we ran that head-to-head in RX 9070 XT vs RTX 5060 Ti 16GB.

Windows ARM native inference

The second roadmap item matters if you’ve been eyeing a Snapdragon X Elite laptop or a future ARM Windows mini-PC as an always-on, low-power inference box. First-class native Ollama support on Windows ARM removes the current awkwardness of emulation and CPU-only fallback.

Temper expectations on speed, though. NPU-class ARM silicon is a tokens-per-watt play, not a tokens-per-second play — an 8B model on a Snapdragon X Elite lands in the single-digit-to-low-teens tok/s range, versus ~95 tok/s on a used 3090. The audience here is people who want a quiet, cheap, always-on assistant, not raw throughput. If that’s you, the win is real; if you want speed, buy a discrete GPU.

Multi-GPU scheduling: read this before buying a second card

Today, Ollama can aggregate VRAM across multiple GPUs but lacks intelligent load balancing. The mental model to keep is blunt: Ollama multi-GPU is VRAM expansion first, performance acceleration second. If a model fits entirely on one card, the single-GPU path is usually faster than splitting it, because splitting adds inter-GPU transfer overhead. You use a second GPU to run a bigger model, not to run the same model faster.

The stated roadmap improvement is a proper scheduler across 2+ GPU setups. That’s meaningful for the classic home-lab builds:

• Dual used RTX 3090 = 48GB total, the cheapest comfortable path to a 70B model.
• Dual RX 7900 XT = 40GB total for well under the price of one RTX 4090.

Two caveats before you order a second card. First, AMD multi-GPU setups hit more driver, ROCm-version, and GFX-version compatibility issues than NVIDIA — you control card selection with ROCR_VISIBLE_DEVICES (the AMD equivalent of CUDA_VISIBLE_DEVICES). Second, the physical build gets real: two 300W+ cards need PCIe lanes, airflow, and a serious PSU. We cover the interconnect tradeoffs in multi-GPU for local AI: NVLink vs PCIe. For the broader AMD-on-Linux picture, see AMD ROCm for local AI in 2026.

The VC-backing signal — and the license to watch

Two ways to read $65M into an open-source tool, and both are true.

The bullish read: ROCm, Windows ARM, and multi-GPU scheduling are now committed budget lines, not community experiments. A used RX 7900 XT or a dual-3090 rig is a safer bet than it was 12 months ago because the tool driving it has runway and staff.

The cautious read: investors need returns, and open-source infrastructure companies have a well-worn path for finding them. As of July 9, 2026, Ollama’s license is still MIT — genuinely permissive, no strings. But remember the HashiCorp precedent: Terraform was open source until 2023, when HashiCorp relicensed to the Business Source License (BSL) and the community forked OpenTofu in response. Nobody is saying Ollama will do this. The point is that “MIT today” is a fact, not a guarantee, and the thing that changes the incentive is exactly the kind of VC round that just closed.

What to actually do about it: nothing dramatic. Keep your workflow portable. Ollama is a friendly wrapper over llama.cpp; your GGUF model files work directly with llama.cpp, LM Studio, and vLLM. If Ollama ever open-cores its way into a paid tier you don’t want, you can move to raw llama.cpp in an afternoon. Build on the model files and the OpenAI-compatible API, not on Ollama-specific magic, and you’re insulated either way.

Honest take: a decision framework

• You want cheap 20GB+ VRAM and don’t mind a 20–25% speed tax: buy a used RX 7900 XT (20GB, 800 GB/s, ~$535–$600). The funding makes AMD a safer bet, and ROCm 7.2 already made it usable.
• You want the most tokens/sec per dollar under 24GB: buy a used RTX 3090. CUDA maturity plus 936 GB/s still wins on speed.
• You were about to buy an RX 9070 XT for AI: reconsider — the older 7900 XT has more VRAM and more bandwidth for similar money.
• You want always-on, low-power inference: the Windows ARM roadmap is for you, but accept single-digit tok/s.
• You don’t want to buy hardware yet: rent. A quick evaluation on RunPod costs a few dollars and tells you whether ROCm-on-AMD fits your workflow before you commit $600.

The bottom line is boring, which is the correct outcome: Ollama’s funding round doesn’t break anything today and quietly de-risks AMD home-lab builds. Buy for VRAM-per-dollar and bandwidth, keep your models portable, and watch the license — not because it’s changing, but because now there’s a reason it could.

If you’re using Ollama as a backend for coding tools like Cline or Cursor, the funding matters there too — our sister site aicoderscope.com tracks the BYOK coding-agent angle, and aifoss.dev covers the open-source and licensing side in more depth.

FAQ

Did Ollama change its license after the funding? No. As of July 9, 2026, Ollama is still MIT-licensed. The MIT license file remains in the main GitHub repository. The caution in this article is forward-looking, not a report of a change.

Is AMD finally viable for local AI, or is that hype? Viable, with an asterisk. ROCm 7.2 (March 2026) reached out-of-the-box parity with CUDA across Ollama, LM Studio, llama.cpp, and vLLM. The remaining gap is ~20–25% latency from the HIP translation layer. For inference you’ll notice it in tokens/sec but not in whether things work.

Should I buy the RX 9070 XT or the RX 7900 XT for local LLMs? For LLM inference, the RX 7900 XT — it has 20GB (vs 16GB) and 800 GB/s (vs 640 GB/s) for similar or lower used prices. The 9070 XT is the better gaming card; bandwidth-bound AI decode favors the older part.

Will the multi-GPU scheduler make two cards run a model twice as fast? No. Ollama multi-GPU is primarily for fitting bigger models across pooled VRAM. Splitting a model that already fits on one card adds transfer overhead. The roadmap improves load balancing, not the fundamental physics.

Does the funding mean Ollama will get faster? Indirectly. It funds broader hardware coverage and polish, but raw decode speed is capped by memory bandwidth on your GPU. Ollama already runs within a few percent of raw llama.cpp; the wins come from your hardware, not the wrapper.

Sources

• Popular open source AI developer tool Ollama raises $65M, grows to nearly 9M users — TechCrunch
• Ollama raises $65M as its open-model runner hits nearly 9M developers — The Next Web
• Ollama Raises $65M Series B Funding to Grow Its Open Source AI Platform — AIwire/HPCwire
• ollama/LICENSE (MIT) — GitHub
• Hardware support (ROCm v7 / multi-GPU / ROCR_VISIBLE_DEVICES) — Ollama Docs
• Running Local AI on AMD: ROCm, Ollama, and LM Studio Performance in 2026 — MindStudio
• AMD ROCm Local LLM Setup (2026): 96 tok/s on RX 7900 XTX — Local AI Master
• AMD vs NVIDIA for Local AI Inference in 2026: ROCm Has Finally Caught Up — GPU Hunter
• RX 7900 XT Price Tracker US — Best Value GPU
• RX 9070 XT Price Tracker US — Best Value GPU
• AMD Radeon RX 9070 XT Benchmarks and Specs (640 GB/s, 16GB, 304W) — Notebookcheck

Last updated July 12, 2026. Prices and specs change; verify current rates before purchasing.

Recommended Gear

• RX 7900 XT 20GB — best VRAM-per-dollar and bandwidth for AMD local inference (~$535–$600 used, 800 GB/s).
• RX 9070 XT 16GB — newer RDNA 4 card; great for gaming, but 640 GB/s makes it the weaker AI buy vs the 7900 XT.
• RX 7900 XTX 24GB — AMD’s top consumer card for 24GB local models (~$820 used, 960 GB/s).
• Used RTX 3090 24GB — the CUDA value king if you want maximum tokens/sec under 24GB (~$1,050–$1,254, 936 GB/s).