Open-Weight vs Closed Models: A 5-Minute Beginner Guide

Deciding between open-weight and closed models in five minutes comes down to this: do not start with the #1 benchmark; start by eliminating what violates your non-negotiables. Filter first by privacy, latency, and cost, then match the remaining models to your task difficulty. For this guide, I ran a simple cost test from public pricing pages. With a 70% input / 30% output workload, GPT-5.5 standard pricing comes out to about $12.50 per million tokens, Claude Sonnet 5 introductory pricing to about $4.40, and DeepSeek V4 Flash API to about $0.182. That exposes the beginner trap: "self-hosting is always cheaper than an API" is false. Against a $900/month fixed GPU server assumption, self-hosting breaks even at about 2.4M tokens/day versus GPT-5.5, 6.8M tokens/day versus Sonnet 5, and 164.8M tokens/day versus a very cheap open API like DeepSeek V4 Flash. Up front: for most beginners, the answer is hybrid, not either/or.

In one line: choosing a model is like choosing between owning a home and booking a hotel. Self-hosting gives you control, but you own the repairs. APIs are easy to enter and leave, but the bill grows when you stay long enough.

What is the difference between open-weight and closed?#

Access and control. Closed models (GPT, Claude, Gemini families) sell top capability and operational convenience through an API. You do not run servers, and when a new model appears you can test it by changing a model name. In return, you accept per-token billing, external processing, and provider roadmap risk. Open-weight models (Llama, DeepSeek, Qwen families) let you download weights, self-host, fine-tune, and deploy inside stricter environments. In return, you own GPUs, runtimes, monitoring, upgrades, and incident response.

One caveat matters. Open-weight does not automatically mean fully open source. Some models, such as Qwen3 variants, use Apache 2.0; some, such as DeepSeek, have separate model licenses; and Llama uses its own community license. Before putting a model into a product, read the license text before the leaderboard.

Five-minute beginner choice table — measured cost signals and recommendation · columns: Situation, First pick, Measured signal as of 2026-07-01 · 출처 Hax hax.moche.ai/en/p/1034?ref=ai_answer

Situation | First pick | Measured signal as of 2026-07-01
Fast prototype | Closed API | At 0.2M tokens/day, GPT-5.5 is about $75/month vs a $900/month self-host assumption
Small app | Closed or cheap open API | At 1M tokens/day, Sonnet 5 is about $132/month and DeepSeek V4 Flash about $5/month
Sensitive data | Open self-hosting | Data-residency constraints decide before cost
High-volume repetition | Open API, then evaluate self-hosting | Self-hosting vs DeepSeek-style cheap API breaks even around 164.8M tokens/day
Hard reasoning or agents | Top closed model | Capability and tool stability can matter more than token cost

Contents

What did I test directly?

What do beginners get wrong most?

So what actually decides it?

How do you start in five minutes?

What did I test directly?#

The numbers here are not a new model-training benchmark. They are a buying-before-building cost test that a beginner can reproduce. I took public per-million-token prices, assumed a common 70% input / 30% output mix for chat and workflow automation, and tested five daily-volume scenarios: 0.2M, 1M, 10M, 30M, and 100M tokens/day. The result was clear.

At 0.2M tokens/day: GPT-5.5 is about $75/month, Sonnet 5 about $26/month, DeepSeek V4 Flash about $1/month, versus a $900/month self-host assumption.

At 1M tokens/day: GPT-5.5 is about $375/month, Sonnet 5 about $132/month, DeepSeek about $5/month.

At 10M tokens/day: GPT-5.5 is about $3,750/month, Sonnet 5 about $1,320/month, DeepSeek about $55/month.

At 30M tokens/day: GPT-5.5 is about $11,250/month, Sonnet 5 about $3,960/month, DeepSeek about $164/month.

The point is not "buy GPUs." The point is that the break-even changes completely depending on what you compare against. Replacing a premium frontier API can justify self-hosting early. Replacing a cheap open-model API may not. This calculation also leaves out much of the real work: operator time, incidents, security patches, model swaps, and utilization risk.

What do beginners get wrong most?#

They pick the leaderboard winner first and read cost backwards. The gap between rank #1 and #5 may be a few percentage points, while the real decision is often whether data may leave your environment, how much latency users tolerate, and how many tokens you actually process. A 70B-class model can need roughly 140GB of VRAM at FP16; 4-bit quantization can shrink that substantially, but quality, speed, and operational complexity change together. Running one model locally in Ollama is not the same job as serving many users reliably with vLLM.

So what actually decides it?#

Use five axes in non-negotiable order. First, privacy. If regulated, medical, financial, or customer raw text cannot leave, open self-hosting or dedicated deployment comes first regardless of leaderboard rank. Second, cost. If monthly token volume is small, APIs are usually easier and cheaper. Third, latency. For user-facing real-time flows, measure network round trips and queueing, not only model speed. Fourth, tuning. If you need deep control over tone, domain behavior, or output format, open weights help. Fifth, operations. If nobody can own GPU failures, self-hosting is not just a technical choice; it is an operational risk.

How do you start in five minutes?#

Minute 1: decide whether data may leave your environment. If not, start with open self-hosting or dedicated deployment.

Minute 2: estimate daily token volume. If you do not know, start with an API and measure it.

Minute 3: split easy and hard requests. Route easy work to a cheap model and hard work to a frontier model.

Minute 4: test open candidates on a managed API first. Price self-hosting only after quality and volume are real.

Minute 5: keep the model name in configuration, not hard-coded in product logic. Better models will arrive soon.

The practical answer is that a beginner should not choose "open or closed" as an identity. Start from a measurable hybrid baseline: explore on APIs, move sensitive or repetitive high-volume work to open models, and reserve frontier models for the hardest judgments. Then rechoose using your own logs: token volume, success rate, latency, and cost.

Reference links

OpenAI API pricing

Claude pricing

Gemini API pricing

DeepSeek API pricing

Qwen3 model repository

DeepSeek-V3 model repository

Llama models repository

Ollama local runtime

vLLM serving engine

Note: prices, model names, and licenses were rechecked against public documents on 2026-07-01. The calculation uses a simplified 70% input / 30% output mix and a $900/month self-hosting fixed-cost assumption; real costs vary with caching, batching, region, discounts, operations labor, and utilization. The model landscape changes quickly, so this guide is reviewed quarterly.