The Kit

The closed frontier — capability by API

OpenAI — GPT family + o-series reasoning models The incumbent by mindshare. The GPT line covers general chat, vision, and audio; the o-series (and successors) are the reasoning tier — trained with RL on verifiable tasks, they spend inference-time compute "thinking" and price accordingly. Reach for it: broadest ecosystem and tooling, strong all-around capability, the default enterprise checkbox. Caveats: pricing tiers and model naming churn constantly; reasoning-tier latency and cost surprise teams sized for chat models; deprecation schedule demands you build model-agnostic.

Anthropic — Claude family The Opus/Sonnet/Haiku tiering: flagship / balanced workhorse / fast-and-cheap. Reputation earned on long- context work, code, and agentic reliability — Claude models run a large share of production coding agents. Post-training runs on Constitutional AI (RLAIF). Reach for it: coding and agent workloads, long documents, enterprises that weight the safety posture. Caveats: capability edge trades punches with OpenAI release-by- release — hold model choice loosely; historically stricter refusals on edge-case content. (Disclosure beyond the affiliate tag: this site is researched and written with Claude models. The entry stays to the same bar as every other.)

Google — Gemini family The vertical-integration play: Google trains on its own TPUs, serves from its own cloud, and distributes through Search, Android, and Workspace. Technical signature is context length — the 1M+ token tier arrived here first ⚑ unverified — plus strong native multimodality and aggressive price-performance in the Flash tier. Reach for it: very long documents/video, multimodal pipelines, GCP-committed shops, cost-sensitive volume on Flash. Caveats: product/API surface reorganizes often; enterprise ergonomics historically trail the API leaders.

Also in the closed tier: xAI (Grok) — frontier-scale compute, distribution via X, real-time data angle; Amazon (Nova) + Bedrock — models mid-pack, but Bedrock is many enterprises' procurement path to everyone else's models; Microsoft Azure OpenAI — the compliance-wrapped route to OpenAI models.

Open weights — capability as a download

Meta — Llama family The release that created the category. Llama weights seeded an entire ecosystem — llama.cpp, Ollama, the fine-tune universe — and set the commoditization clock ticking. Reach for it: the widest tooling and community support of any open family; sizes from edge to datacenter. Caveats: "open" is Meta's license, not OSI open source — usage terms apply ⚑ unverified; flagship quality vs the Chinese open labs is now contested generation by generation.

Mistral AI The European lab that proved small-and-sharp: efficient dense models and early open MoE (Mixtral) with weights on a torrent link. Splits its line between open weights and closed API models. Reach for it: strong capability-per-parameter, EU jurisdiction and sovereignty requirements, Apache- licensed options. Caveats: caught between free-er (Chinese labs) and stronger (frontier closed); flagship releases increasingly API-first.

Alibaba — Qwen family The most complete open lineup: dense and MoE, 0.5B to frontier-scale, plus dedicated coder, vision, audio, and embedding lines, with genuinely strong multilingual coverage. On open leaderboards, Qwen releases routinely sit at or near the top ⚑ unverified. Reach for it: best-of-open at many sizes, non-English workloads, the coder line for local dev assistants. Caveats: Alibaba provenance is a compliance question in some enterprises (weights are inspectable, but procurement is procurement); benchmark-tuning accusations recur across all open labs — eval on your task.

DeepSeek The lab that moved the market. V3 (efficient MoE) and R1 (open reasoning, RL-trained, chain-of-thought visible) shipped near-frontier capability as MIT-licensed weights and triggered the industry's loudest repricing of training-cost assumptions ⚑ unverified. Reach for it: strongest open reasoning per dollar; research transparency (published methods others imitate). Caveats: the $5.6M training-cost figure excludes most true costs ⚑ unverified; hosted-API data residency (China) is a separate question from running the weights yourself — distinguish the file from the service.

Also in the open tier: Google Gemma (small, polished, Gemini-adjacent), Microsoft Phi (small-model data-quality experiments), NVIDIA Nemotron (open fine-tunes tuned to sell silicon), Allen AI OLMo (actually-open: data + code + weights — what "open source" should mean here).

Embedding models — the retrieval workhorses

OpenAI text-embedding line — default-safe API choice, Matryoshka-truncatable dims. Cohere Embed + Rerank — retrieval specialist; the reranker is the cheap RAG accuracy upgrade. Voyage AI — retrieval-focused boutique (now Anthropic-adjacent ⚑ unverified), strong domain models (code, law, finance). Open weights: BGE-M3 (multilingual standard), Nomic (fully open recipe), Qwen embedding line, E5/GTE families — all servable locally; this site's own RAG runs on open embeddings for exactly the privacy reasons the dossier names.

Inference providers — someone else's GPUs, by the token

The business the open-weight disruption created: you bring the model choice, they bring optimized serving. Differentiation is price, speed, model catalog, and enterprise features — compare live in [asset: D34 Model comparison explorer].

Together AI — the broad catalog: serverless per-token endpoints across the open-weight universe, plus dedicated endpoints and fine-tuning. Reach for it: fast model-shopping across open weights, one API. Caveats: per-token serverless beats self-hosting only until utilization is high and steady — do the math at volume.

Fireworks AI — the performance angle: aggressive inference optimization (custom kernels, speculative decoding), function-calling-tuned serving, compound-AI features. Reach for it: latency-sensitive production on open models. Caveats: catalog narrower than Together's; benchmark their speed claims on your workload ⚑ unverified.

Replicate — the long tail: thousands of community models — image, video, audio, niche fine- tunes — behind one API, cold starts included. Reach for it: prototyping anything weird, multimodal experiments, "someone already packaged that model." Caveats: cold-start latency and per-second pricing make it a prototyping surface more than a high-volume production spine.

Groq — the hardware bet: custom LPU silicon serving a small open-model menu at conspicuously high tokens-per-second ⚑ unverified. Reach for it: real-time/voice UX where latency is the product. Caveats: limited catalog, limited context at the extremes; the wow-demo speed matters only if latency is actually your constraint. (No affiliate program at listing time ⚑ unverified — the entry stays; the guardrail is that coverage never depends on the link.)

Baseten — the deploy-your-own tier: dedicated model serving with autoscaling, bring custom weights and fine-tunes. Reach for it: production serving of your model without building the MLOps yourself. Caveats: dedicated capacity pricing punishes low utilization — this is for real traffic.

Also here: DeepInfra, Novita, Hyperbolic (price-floor serverless), OpenRouter — the meta-layer: one API routing across every provider above, the practical answer to model-agnostic architecture. GPU-cloud rental (Lambda, CoreWeave, RunPod) is the Hardware layer's Kit — the line: rent tokens here, rent silicon there.

Fine-tuning platforms — behavior shaping as a service

OpenAI fine-tuning — SFT (and preference methods) on GPT-tier hosted models; format/style shaping with zero infrastructure, priced into serving. Together fine-tuning — LoRA and full fine-tunes on open weights, weights exportable — the no-lock-in argument. Fireworks fine-tuning — tune-then-serve on their fast stack. Predibase — LoRA specialists; many adapters multiplexed on one base model (LoRAX) for per-tenant customization. Modal — not a tuning product but the serverless-GPU substrate a lot of custom training actually runs on. Open toolchain: Axolotl, Unsloth, Hugging Face TRL/PEFT — the DIY route: config-file fine-tunes on rented GPUs; Unsloth's memory tricks put 70B-class LoRA on a single card ⚑ unverified. Hugging Face — the layer's commons: the model hub itself, plus AutoTrain and inference endpoints.

The honest header for this whole section, per the pretraining-vs-fine-tuning guide: most teams reaching for fine-tuning need RAG or better prompting. The platforms are listed for when fine-tuning is actually the tool.