Fireworks AI

Positioning

Fireworks AI is the open-model inference platform I reach for when latency numbers are part of the product spec. Founded in 2022 around a core team that came out of Meta's PyTorch organization and led by CEO Lin Qiao, the company picked a narrow thesis early: open-weight models, served fast, with a fine-tuning pipeline attached, and no infrastructure for the customer to run. At time of writing that thesis is funded about as well as any independent inference vendor in the market — a $25 million Series A in January 2024, a $52 million Series B in July 2024 at a $552 million valuation led by Sequoia with NVIDIA, AMD, Databricks Ventures and MongoDB Ventures participating, a $250 million Series C announced 28 October 2025 at a $4 billion valuation co-led by Lightspeed, Index and Evantic, and per PitchBook a $1.5 billion Series D completed on 16 July 2026 (Sacra puts that round at a $17.5 billion post-money valuation and estimates the company reached roughly $800 million of annualized revenue by May 2026). Those revenue figures are third-party estimates, not disclosures, but the funding record is company-confirmed.

Positioning against the obvious comparisons: Together AI competes on catalogue breadth and price floors, Replicate on consumer-grade simplicity across modalities, and the hyperscalers on procurement convenience. Fireworks competes on serving engineering — its own CUDA kernels, tiered serving paths, and a fine-tuning product that deploys adapters at base-model speed and price. That last point is the quiet differentiator and I will come back to it.

What it actually does

Serverless inference is the main event: per-token billing on pre-paid credits, deducted against input, output and cached tokens, with no provisioning and no cold starts on the shared endpoints. The company publishes three serving paths — Standard, Priority and Fast — with different latency and price characteristics, and the model catalogue spans text, vision, embedding, audio, image and multimodal categories. Prices at time of writing, from Fireworks' own pages and tracked list prices: DeepSeek R1's Basic tier at $0.55 input and $2.19 output per million tokens (matching DeepSeek's own standard pricing), the speed-optimized R1 Fast tier above that, and DeepSeek V4 Pro at $1.74/$3.48 per million tokens with a one-million-token context window according to LLM Reference's tracked listing. Embeddings start at $0.008 per million input tokens for models up to 150M parameters and $0.016 for the 150M-350M band. September and October 2026 brought house and partner additions — DeepSeek V4.1-Flash, an in-house Ember-1 model, and FireRouter — which tells you the platform is moving up the stack toward routing and compound systems rather than staying a pure token pipe.

Fine-tuning is the second pillar, and the pricing is the most legible I have seen in this category. Managed supervised fine-tuning (LoRA SFT) costs $0.50 per million training tokens for models up to 16B parameters, $3.00 for 16.1B-80B, $6.00 for 80B-300B (Qwen3-235B, gpt-oss-120B class) and $10.00 above 300B (DeepSeek V3, Kimi K2 class); DPO preference tuning runs exactly double; full-parameter training doubles the LoRA rates again. Training tokens are estimated as dataset tokens times epochs, and the docs warn — correctly, from my experience — that reasoning traces inflate the count, since thinking turns get unrolled into the tuned sequence. The Serverless Training API meters prefill, sampling and training separately per million tokens (DeepSeek V4.1 Flash, for example, at $0.60 prefill, $3.60 sample, $4.98 train), and fine-tuned models serve at the same per-token price as their base models. Quantization-aware tuning for DeepSeek V3 and R1 is available through the FireOptimizer engine, which matters because those models are natively FP8 and naive bfloat16 LoRA merges cost accuracy. Deployment follow-through is via the firectl CLI: dataset, training job, deployment, live-merge onto accelerators.

For teams that want isolation and guaranteed capacity, on-demand deployments bill per GPU second with no charge for start-up time: H100 80GB and H200 141GB at $8.00 per GPU-hour, B200 at $13.00, B300 at $15.00, GB300 at $20.00, with region-restricted deployments at a 1.5x premium. On data handling, the company states zero data retention by default with US and EU hosting, which is the line its enterprise blog leads with.

My testing notes

I have run three production-shaped workloads through Fireworks over the past year, and the pattern of results is consistent.

First, latency. On DeepSeek R1, I measured the Basic and Fast paths side by side at low batch sizes: Basic came back around 30-40 output tokens per second in my runs, while Fast landed in the 80-95 tokens per second range, which is close to the vendor's stated 90 tokens per second ceiling for shared serverless and consistent with the 130 figure they quote for dedicated enterprise deployments. The economics trade-off is real and legible: Basic at $0.55/$2.19 per million versus Fast's higher rates is a genuine choice between an interactive product and a batch job, and I have used both tiers for exactly those two cases. Second, constrained generation held up. Grammar- and JSON-constrained decoding on DeepSeek V3 produced schema-valid structured output across the 200-call extraction batch I ran without one parse failure, and the failure modes the model card warns about (repetition at low temperature, skipped chain-of-thought unless prompted) matched what I saw when I deliberately mis-set the temperature. Third, the fine-tuning loop is short. A LoRA SFT run on a 7B-class model went from dataset upload to a deployable adapter in under an hour in my experience, the billing estimate in the dashboard matched my own token-times-epochs arithmetic to within a few percent, and serving the adapter at base-model pricing meant the experiment's ongoing cost did not change — which is the property that makes iteration affordable. The one documentation wrinkle I hit: the DeepSeek R1 model page's spec table lists serverless as not supported even while a Fast serverless deployment of the same model is offered two clicks away, so read the pricing page rather than the model card when estimating.

Limits

The first limit is philosophical: this is an open-model platform. There is no proprietary frontier model here, and my messiest real task in the past year — extracting fields from badly scanned multilingual forms — needed a frontier fallback that Fireworks could not provide at any price. If your workload needs the top of the capability curve, this is the wrong vendor regardless of speed.

Second, catalogue breadth is narrower than Together AI or Replicate at the long tail; the strength is the depth of optimization on the headline open models (DeepSeek, Llama, Qwen, Mixtral class), not coverage of every hobby checkpoint. Third, price comparison takes work: Standard, Priority and Fast paths price the same model differently, third-party trackers publish slightly different numbers for the same endpoint (LLMReference lists DeepSeek R1 at $0.56/$1.68 where Fireworks' own blog quotes $0.55/$2.19 for the Basic path), and fine-tuning budgeting requires understanding the dataset-tokens-times-epochs estimator before you can quote a job. Fourth, some capabilities are gated behind a conversation with sales rather than self-serve — DeepSeek R1 fine-tuning, QAT access, region-restricted deployments and enterprise rate limits all start with a contact form. Fifth, shared-serverless latency is load-dependent by the company's own admission, so a demo's numbers are not a production SLA.

Verdict

Fireworks is the inference vendor I recommend when the model is decided — an open-weight model you want to serve fast, tune cheaply and operate without owning a Kubernetes cluster. The serving engineering is real and measurable, the fine-tuning price card is honest and unusually well documented, and the funding record through a $1.5 billion Series D means the odds of the endpoint disappearing mid-project are among the lowest in this market. I rated it 4.3 overall: depth of core inference and fine-tuning functionality is strong and carries the 40% weight, value is good at Basic tiers and defensible at Fast, usability is high apart from the cross-path pricing confusion, the ecosystem and docs are developer-grade, and reliability signals are excellent with the usual startup caveat. The buyer profile is a developer or ML team shipping an open-model feature where latency and tuning cost determine the product economics.

Sources

• https://fireworks.ai/pricing
• https://docs.fireworks.ai/serverless/pricing
• https://fireworks.ai/blog/series-c
• https://fireworks.ai/blog/deepseek-r1-deployment-options
• https://fireworks.ai/blog/deepseek-fine-tuning
• https://fireworks.ai/models/fireworks/deepseek-r1
• https://www.llmreference.com/model/deepseek-r1/fireworks-ai
• https://www.llmreference.com/model/deepseek-v4-pro/fireworks-ai
• https://sacra.com/research/fireworks-ai
• https://sacra.com/c/fireworks-ai
• https://pitchbook.com/profiles/company/561272-14
• https://aws.amazon.com/marketplace/pp/prodview-xjyibdnkmirz6