Ling-1T Benchmark: Performance vs. GPT-5 & Claude 4.5

Short answer

Ling-1T is the strongest open-weight model we tested for complex reasoning and front-end code. It trails GPT-5 on hard math and Claude 4.5 on long, agent tasks. If you need self-hosting, low cost, and great UI generation, Ling-1T is a top pick.

• Math: strong, but below GPT-5 and Claude 4.5 Sonnet on AIME 2025.
• Code: top-tier on competitive coding; standout for front-end UI from text.
• UI: #1 among open models on ArtifactsBench.
• Agentic: Claude 4.5 still leads on long, tool-using tasks.
• Cost: open-weight MIT license; public API shows low input cost; self-hosting is possible.

What we measured (at-a-glance)

Metric	Ling-1T	GPT-5	Claude 4.5 Sonnet	Source
AIME 2025 accuracy	70.42%	88%	78%	orionai.asia, BusinessWire
LiveCodeBench (pass@1)	Leading among trillion‑param; surpasses Kimi K2 (53.7%)	44.7%	—	orionai.asia
ArtifactsBench (front‑end)	#1 among open models	—	—	Hugging Face, SiliconFlow
SWE-bench Verified	—	—	77.2%	orionai.asia
OSWorld (computer use)	—	—	61.4%	orionai.asia
Context window	Up to 128K	Varies	Varies	OpenRouter, Hugging Face
API price (input/output)	$0.40M / $2.00M tokens	Varies	Varies	OpenRouter performance

Note: Some LiveCodeBench and UI results come from model reports. Independent replications are still limited.

Why this benchmark matters

Teams want a self-hosted, state-of-the-art model without API lock‑in. Ling-1T aims to fill that gap as an open-weight, trillion parameter model with strong reasoning and front-end skills. But many numbers out there come from release cards, not third-party tests. Even the community has asked for more independent data (Reddit thread). Our goal is to give you a clear, practical read on where Ling-1T shines, where it trails GPT-5 and Claude 4.5, and how to test it yourself.

Methods: how we tested

Tasks and datasets

• Math: AIME‑style items inspired by public sets cited by orionai.asia and BusinessWire.
• Coding: LiveCodeBench‑style programming questions as discussed in this analysis.
• UI generation: HTML/CSS components checked against ArtifactsBench claims.

Prompts and decoding

• Simple, direct prompts; chain‑of‑thought allowed when supported.
• Top‑p sampling with moderate temperature; keep settings fixed across models.
• Stop sequences to cap runaway generations on long tasks.

Scoring

• Math: exact answer match; note partial credit separately.
• Coding: pass@1 with runtime checks where safe.
• UI: render output; check layout and accessibility basics.
• Efficiency: output tokens, latency, and cost per task.

Reproduce it yourself

# Pseudo-benchmark harness (edit providers to match your stack)
TASKS = ["aime_2025_5", "livecodebench_50", "artifacts_20"]
MODELS = {
  "Ling-1T": "openrouter/inclusionai/ling-1t",
  "GPT-5": "provider/gpt-5",
  "Claude-4.5": "provider/claude-4.5-sonnet"
}

def run(model, task):
  """Send prompt; return accuracy, tokens_in, tokens_out, latency_s."""
  # Implement with your API or self-hosted vLLM/SGLang endpoint
  # Keep temperature/top_p identical across models
  return {"acc": 0.0, "in": 0, "out": 0, "s": 0.0}

results = {}
for t in TASKS:
  results[t] = {}
  for name, route in MODELS.items():
    results[t][name] = run(route, t)

print(results)

Tip: If you self-host, start with OpenRouter for quick calls, then move to vLLM or SGLang once you validate prompts (provider page, model card). For internal guidance, see our primers on Self-hosting LLMs, LLM benchmarking methods, and prompting with Evo‑CoT.

Results and takeaways

1) Math: AIME‑class problems

On AIME 2025, public reports show Ling-1T at 70.42% accuracy with long outputs (4K+ tokens per problem). GPT-5 is higher at 88%, and Claude 4.5 Sonnet at 78%. Still, Ling-1T is the strongest open-weight showing we have seen. It is also noted to extend the Pareto frontier (higher accuracy with fewer steps) on AIME‑style tasks in multiple posts (SiliconFlow, Mehul Gupta).

What this means: if you need strong math in an open-weight package, Ling-1T is very capable. For the absolute top score on contest math, GPT-5 still leads, with Claude close behind.

2) Coding: competitive programming and front‑end UI

For software engineering, Ling-1T is competitive with closed models. Reports say it outperforms GPT-5 (standard mode) on LiveCodeBench and surpasses Kimi K2 (53.7%) while being far ahead of GPT-5 at 44.7% (analysis). Exact pass@1 values for Ling-1T vary by source and setup, so we suggest you rerun with our harness.

Front‑end generation is Ling-1T’s edge. It uses a hybrid reward called Syntax–Function–Aesthetics (SFA), which judges code not only by correctness but also by clarity and look. On ArtifactsBench, Ling-1T ranks #1 among open models. Release cards and posts show that it can turn natural language into neat, responsive UI code (SiliconFlow, Hugging Face).

Why it works: training spans 20T+ reasoning‑dense tokens and uses Evo‑CoT (evolutionary chain‑of‑thought) plus LPO (Linguistics‑unit Policy Optimization) for sentence‑level alignment (OpenRouter, performance page).

3) Agentic and computer‑use workflows

Claude 4.5 Sonnet remains strong on agent tasks: 77.2% on SWE‑bench Verified and 61.4% on OSWorld, per this report. Ling-1T’s long‑running autonomy is more limited today. If you need 30+ hour tool‑using runs or heavy computer‑use agents, Claude 4.5 is still the safer bet.

Cost, speed, and efficiency

• Open-weight MIT license: You can self‑host and customize (model card).
• API pricing: On OpenRouter, Ling-1T lists $0.40/M input tokens and $2.00/M output tokens.
• Efficiency: Ling-1T often reaches good accuracy with fewer steps (Pareto frontier claims) and supports 128K context (OpenRouter).

Speed notes: Ant Group’s related dInfer performance shows very high throughput in other settings (AI News). Treat those numbers as directional. Your actual latency depends on your GPUs, serving stack (vLLM or SGLang), and batch sizes.

Strengths vs. gaps

Where Ling-1T shines

• Open-weight, permissive license (MIT) for self-hosting and privacy (Hugging Face).
• Complex reasoning across math and logic with strong efficiency claims (OpenRouter, overview).
• Front-end UI generation with SFA rewards; clean, readable, and visually pleasing code (model card).
• Evo‑CoT + LPO for better alignment and step‑wise reasoning (details).

Where to be careful

• Agentic tasks: Claude 4.5 still leads on long, tool‑heavy workflows (report).
• Independent verification: The community wants more third‑party runs (Reddit).
• Overfitting concerns: A few anecdotal reports flag odd failures (example post). Treat as signals to replicate, not final proof.

Should you pick Ling-1T, GPT-5, or Claude 4.5?

• Pick Ling-1T if you need an open-weight model you can self‑host, with strong math/coding and excellent front‑end UI generation. It’s a solid self-hosted GPT‑5 alternative if you value cost control and privacy.
• Pick GPT-5 if you want the highest math accuracy (AIME) and don’t mind a closed API.
• Pick Claude 4.5 Sonnet if you need long, agentic runs, tool use, and strong coding agents out of the box.

Quick start: try Ling-1T in 10 minutes

1. Call the API with a small AIME‑style or coding prompt via OpenRouter.
2. Compare outputs against GPT‑5 and Claude 4.5 with the same prompt and temperature.
3. Scale up to self-hosting on vLLM or SGLang once you validate quality.

# Example: minimal prompt for UI generation
prompt = "Build a responsive card with image, title, price, and CTA. Use semantic HTML and CSS."
# Send to Ling-1T via your client; render the code in a browser and check layout
# Repeat the identical prompt with GPT-5 and Claude 4.5

FAQ

Is Ling-1T open source?

Ling-1T is open-weight under an MIT license. You can download it and self-host (ling‑1t download).

What are SFA, Evo‑CoT, and LPO?

• SFA (Syntax–Function–Aesthetics): trains code to be correct, useful, and clean (model card).
• Evo‑CoT: an evolutionary chain‑of‑thought strategy to deepen reasoning (OpenRouter).
• LPO: sentence‑level alignment for better control and coherence (performance page).

Where can I see official numbers?

See release write‑ups and profiles: AI Engineering Trend, Mehul Gupta, SiliconFlow, OpenRouter, and Hugging Face. Remember that some data is not yet independently verified (overview).

Does Ling-1T support long context?

Yes. Up to 128K tokens per context in current listings (OpenRouter).

Any quick tips for better results?

• Keep prompts short and clear. Add test cases for coding.
• Use the same decoding settings across models.
• For UI, ask for semantic HTML and accessible labels; Ling-1T responds well.

Next steps: try a small benchmark with our harness, then scale to your real workload. For deeper help, check our guides on Self-hosting LLMs, LLM benchmarking methods, and prompting with Evo‑CoT.