How to Choose an AI Model: License, Privacy, Cost & Deployment

Teams compare Qwen, DeepSeek, GLM, Kimi, and other offerings against a specific workload and operational requirements. The useful unit of comparison is the exact checkpoint or hosted API: its license, deployment options, service terms, cost, and measured performance on your tasks.

This guide gives you a practical way to compare them. Model names, licenses, prices, and API availability change, so use the linked model cards, terms, and pricing pages as the current source of truth before committing.

1. What work must the model do? Define a few real tasks and what counts as a correct result. A model that does well on a public benchmark may still mishandle your documents, languages, output format, or tool calls.

2. Must inference stay inside your environment? A hosted API sends request data to the service operator. Downloaded weights can be served in your own environment, but only if the runtime, logs, monitoring, and any connected tools also meet your data requirements.

3. Which exact model and license? Check the license attached to the checkpoint you plan to deploy, including any base model it derives from. A provider’s API service, model weights, and sample code can have different terms.

4. What is the full cost at your usage level? Count input, output, cached tokens, images or other modalities, tool charges, and retries. Include compute and operations for self-hosting.

5. Can your team access and operate it? Confirm supported regions, account and payment requirements, quota, rate limits, serving software, hardware, and model retirement policy.

A downloadable checkpoint still comes with license and usage terms. Read the repository’s license for the exact weights, then inspect the inference code, tokenizer, adapters, datasets, and upstream model. A dependency or derivative can carry conditions that differ from the checkpoint you started with.

The difference is concrete: the Qwen team’s Qwen3.5-2B model card identifies that checkpoint as Apache 2.0. The GLM-4.5 model card describes the released weights as MIT-licensed, while the GLM-4.5 code repository uses Apache 2.0 for repository code. Check the artifact you will redistribute or run; do not infer its terms from the project name.

Kimi K3 is another reason to read the actual file: Moonshot publishes a separate Kimi K3 License. It permits use and deployment subject to conditions, including a separate agreement for certain Model-as-a-Service operators over a stated revenue threshold and a naming requirement at a stated product scale. Have qualified counsel assess how those clauses apply to your product. The hosted Kimi API is a service governed by its own platform terms.

A practical license check: save the model ID, repository revision, license text, upstream model, and date you reviewed them. Recheck before fine-tuning, redistributing weights, offering inference to customers, or changing the product’s scale.

A hosted API is often the fastest way to evaluate a model. You avoid managing accelerators and model servers, but you depend on the provider’s endpoint, account, availability, quotas, and service terms. Verify that the API supports the capabilities your app actually needs, such as structured output, tool calling, vision, streaming, or the context length you plan to send. For example, provider model lists can expose the current API model IDs and supported features; DeepSeek documents a model-discovery endpoint.

Self-hosting can give an organization more control over where inference runs and how requests are logged. It also transfers work to the operator: acquire and secure the weights, size the hardware, configure serving and updates, monitor latency and capacity, and keep the runtime patched. A small checkpoint such as Qwen3.5-2B is a more approachable local evaluation than a very large mixture-of-experts model. GLM’s model card, for example, lists GLM-4.5 at 355 billion total parameters (32 billion active) and GLM-4.5-Air at 106 billion total (12 billion active), with downloads and serving guidance in its official repository. Active parameter counts are not a hardware estimate: check checkpoint size, quantization, context, and the selected serving framework against your actual hardware.

Keep the privacy claim precise. Running weights on your own infrastructure can avoid sending prompts to a model API, but does not by itself guarantee that data stays local; review application logs, telemetry, observability tools, backups, and plugins too. With an API, review the provider’s developer agreement and privacy documentation rather than assuming the consumer app policy applies. DeepSeek’s Open Platform terms state that the consumer privacy policy does not cover personal information processed for a developer’s downstream application, and assign the developer disclosure and end-user obligations. Kimi’s Open Platform terms describe how submitted content may be used to provide, maintain, develop, support, and improve its services unless a written agreement provides otherwise; its API privacy policy describes content collection, model improvement, service providers, retention, and states that personal information is stored on servers in Singapore. Policies can change, so verify the current terms, data locations, and any order-specific agreement. Ask each provider about retention, training use, subprocessors, deletion, and contractual controls for your account and region.

For an API estimate, use the provider’s current rates and calculate: uncached input tokens × input rate, plus cached input tokens × cache rate, plus output tokens × output rate, plus applicable image, tool, and service charges. Then multiply by realistic call volume and add retries. A cached prompt, a long generated answer, and a peak-hour request may have different prices. DeepSeek publishes model pricing and peak/off-peak rates; Kimi explains input, output, and cache billing on its pricing page; Z.AI lists current model and tool prices in its pricing documentation. Check those pages again when you budget because rates and model IDs can change.

For self-hosting, compare total cost of ownership rather than a token rate: hardware purchase or rental, electricity, quantization trade-offs, engineering time, utilization, redundancy, and serving support. A checkpoint that is inexpensive to download may still be costly to serve at your required throughput. Conversely, a hosted API can cost less for intermittent use because you pay for usage instead of maintaining idle capacity.

Access is part of the fit. Confirm whether your account can create an API key, which countries or regions are served, what payment methods work for your organization, and the current quota and concurrency limits. Kimi publishes a current model list that also identifies discontinued IDs; check for migrations before wiring a model name into production. Ask about service-level commitments and notices for pricing, model, or endpoint changes. Prefer a versioned model identifier where offered and keep a fallback plan that your tests have actually exercised.

Create a small, representative test set before choosing. Include normal requests, difficult edge cases, the languages your users actually write, long inputs, invalid or ambiguous instructions, and tasks that use your real tools. Remove or synthesize confidential data unless your evaluation environment is approved to handle it.

Run the same prompts and tool schemas through each candidate. Score task success, factual or code correctness, required output format, tool-call success, latency, and total cost per successful task. Use fixed settings where the API allows them, repeat nondeterministic cases, and review failures instead of relying only on a composite score. Record the exact model ID, checkpoint revision or API date, prompt, serving framework, quantization, and measured hardware. Re-run the suite when a provider changes a model or when your app changes its prompts.

A team might test a small Qwen checkpoint for local prototyping, compare a GLM weight release against a hosted API for a tool-using workflow, or call DeepSeek or Kimi through a managed service to reduce infrastructure work. Treat each as an option to test against the exact model’s license and capabilities, the provider’s terms and access in your region, and measured results on your workload.

The useful habit is to review model choice as an engineering decision: document the constraints, run a repeatable comparison, and revisit it when your workload, costs, licenses, or provider terms change.