Skip to main content
Open SourceInclusionAI

Ling 3.0 Tiny

Ling 3.0 Tiny is an open-weight chat model from InclusionAI, positioned as the smallest tier in the Ling 3.0 family.

License Open Source
Input from
$0.015 / 1M tokens
on OpenRouter · 1 provider
Output from
$0.045 / 1M tokens
on OpenRouter

API Pricing

ProviderInput / 1MOutput / 1MCached / 1M
$0.015$0.045$0.0030

Prices updated daily. Last check: Nov 15, 2026

Ling 3.0 Tiny pricing by provider

Input, output, and batch rates, plus alternatives, for one provider at a time.

Performance & Benchmarks

Source: Artificial Analysis →
Output Speed
179 t/s
Latency (TTFT)
2.1s

Benchmarks measured Nov 2026. Scores are independent evaluations, not vendor-reported.

Model Details

General

Creator
InclusionAI
Modalities
Text

Capabilities

Open Source
Yes

Strengths & Limitations

Strengths

  • Open weights, so the model can be self-hosted rather than accessed only through a vendor API
  • Lightweight tier within the Ling 3.0 family, suited to cost- and latency-sensitive deployments
  • Measured at approximately 58 output tokens per second in Artificial Analysis testing
  • Self-hosting option allows data to stay inside your own infrastructure for regulated workloads
  • Multiple serving paths possible — hosted API providers or your own GPU instances — which creates price competition
  • Smaller footprint than larger Ling 3.0 variants, reducing the hardware needed for local inference

Limitations

  • Time to first token measured at roughly 2.98 seconds, which is slow for interactive chat compared with many hosted small models
  • Smallest tier in its family, so complex reasoning, long-form coding, and multi-step agentic tasks are better served by larger Ling 3.0 models
  • We do not track a confirmed context window for this model — verify limits with your provider
  • Fewer hosted providers typically serve smaller open-weight models from less widely adopted families, limiting routing options
  • Published benchmark coverage is thinner than for widely adopted Western open-weight models, making quality comparisons harder

Key Features

•Open-weight release from InclusionAI
•Chat/instruction-following text generation
•Tiny tier of the Ling 3.0 model family
•Self-hosting on your own GPU infrastructure
•Availability through third-party hosted inference endpoints
•Measured output throughput of ~58 tokens/second (Artificial Analysis)
•Measured time to first token of ~2.98 seconds (Artificial Analysis)

About Ling 3.0 Tiny

Ling 3.0 Tiny is a text chat model released by InclusionAI with open weights. The "Tiny" designation places it at the lightweight end of the Ling 3.0 lineup, intended for workloads where a smaller model is preferred over the larger members of the same family. Because the weights are openly available, the model can be deployed on self-managed GPU infrastructure in addition to being consumed through hosted inference APIs. In third-party measurements collected by Artificial Analysis, Ling 3.0 Tiny was recorded at roughly 58 output tokens per second with a time to first token of about 2.98 seconds. Both figures depend heavily on the serving provider, batch size, prompt length, and hardware, so they should be treated as one data point rather than a fixed property of the model. We do not track a confirmed context window, modality list, or tool-calling specification for this entry; check the documentation of whichever provider you use for those details. In practice, small open-weight chat models in this class are used for assistant-style text generation, summarization, drafting, and as components inside larger pipelines where per-request cost and the ability to self-host matter more than peak capability. Buyers comparing Ling 3.0 Tiny against other models should weigh it against the larger Ling 3.0 variants when quality is the constraint, and against other open-weight small models when deployment flexibility is the constraint.

Common Use Cases

Ling 3.0 Tiny fits high-volume, cost-sensitive text workloads where a small model is sufficient: classification and routing, short summarization, data extraction and reformatting, template-driven content generation, and first-pass drafting that a larger model later refines. Its open weights make it a reasonable candidate for on-premise or VPC deployments where prompts cannot leave your infrastructure, and for teams that want to fine-tune or quantize a base chat model for a narrow domain. Given the measured time to first token, it is better suited to batch and background processing than to latency-critical interactive chat, unless your serving setup improves on the published figures. For multi-step agent loops, long-document analysis, or demanding code generation, larger Ling 3.0 models or other higher-tier options are the more appropriate comparison.

Frequently Asked Questions

How much does Ling 3.0 Tiny cost to run?

Pricing differs by provider and by pricing model — hosted per-token API rates, batch rates, and the cost of renting GPUs to self-host all behave differently. Because the weights are open, self-hosting is a real alternative to per-token billing for steady, high-volume traffic. See the pricing table on this page for current rates across the providers we track.

What is Ling 3.0 Tiny best used for?

Lightweight, high-throughput text tasks: classification, extraction, summarization, reformatting, and drafting. It is also a practical choice when you need to run a chat model inside your own infrastructure, since the weights are openly available.

How fast is Ling 3.0 Tiny?

Artificial Analysis measured roughly 58 output tokens per second with a time to first token of about 2.98 seconds. Those numbers vary with the serving provider, hardware, prompt length, and concurrency, so your observed latency may differ substantially.

Can I run Ling 3.0 Tiny myself?

Yes — it is an open-weight model from InclusionAI, so it can be downloaded and served on your own GPUs. Check the license terms published with the weights for any restrictions relevant to commercial use.

How does Ling 3.0 Tiny compare to larger Ling 3.0 models?

Tiny is the smallest tier in the family and trades capability for a lower resource footprint. If your workload involves multi-step reasoning, long contexts, or complex code, the larger Ling 3.0 variants are the more appropriate starting point; Tiny targets simpler, higher-volume tasks.