Dola Seed 2.0 Lite vs GLM-5.1: precios y especificaciones, medidos

Cuál usar y cuándo

Dola-Seed-2.0-lite es la opción más barata y de entrada más amplia: $0.25 por millón de entrada frente a $1.4 de glm-5.1 (5.6x menos), $2 frente a $4.4 en salida, $0.05 frente a $0.26 en lecturas de caché, más un contexto de 256000 tokens y entradas de imagen, vídeo y audio. glm-5.1 solo admite texto y es más reciente (publicado el 2026-04-07), con una ventana de 200000 tokens e indicadores explícitos de razonamiento y contexto largo, así que elígelo cuando quieras esos comportamientos declarados en una cadena de texto. Ambos limitan la salida a 131072 tokens, cubren chat, código y herramientas, y permiten desactivar el pensamiento.

Benchmarks

GLM-5.1: el proveedor no ha publicado resultados de benchmarks.

Sobre la mediaNinguno mejorDola Seed 2.0 Lite4 ~~/ 10~~3 ~~/ 10~~

Dola Seed 2.0 Lite GLM-5.1 otros modelos medidos media de los modelos comparados ★ ningún otro modelo puntuó más alto

SWE Multilingual GPT-5.4 High

66.6%

N/A

WenetSpeech test-net (CER)

ningún otro modelo puntuó más alto 4.47%

N/A

OSWorld-Verified

64.4%

N/A

GPQA Diamond

88.4%

N/A

BrowseComp

64%

N/A

MMVU

76.7%

N/A

Publicado por los proveedores: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai

Precios

	Dola Seed 2.0 Lite	GLM-5.1	Δ
Entrada / 1M tokens	$0.25	$1.4	0.18×
Salida / 1M tokens	$2	$4.4	0.45×
Lectura de caché / 1M tokens	$0.05	$0.26	0.19×

Tarifas tomadas del catálogo en vivo al generar el sitio; la página de cada modelo tiene la ficha de precios actualizada.

Dónde queda cada uno: precio de entrada por 1M de tokens entre los 76 modelos de chat que se facturan en esta unidad (escala logarítmica)

Dola Seed 2.0 Lite · $0.25 GLM-5.1 · $1.4

$0.05 · Qwen3 VL Flash $30 · GPT-5.4 Pro

Capacidades

	Dola Seed 2.0 Lite	GLM-5.1
Uso de herramientas	sí	sí
Control del razonamiento	configurable	configurable
Salida estructurada	sí	sí
Caché de prompts	implícito + explícito	implícito (automático)
Duración de la caché	no publicado	no publicado
Prefijo mínimo en caché	1024 tokens	no publicado

Especificaciones

	Dola Seed 2.0 Lite	GLM-5.1
Modalidades de entrada	texto imagen audio vídeo	texto
Modalidades de salida	texto	texto
Lanzamiento	2026-02-14	2026-04-07
Ventana de contexto	256K	200K
Salida máxima	131K	131K
Parámetro de razonamiento	thinking.type reasoning_effort	thinking.type
Valores aceptados	thinking.type enabled disabled (no auto) reasoning_effort minimal low medium high	thinking.type enabled disabled
Valor por defecto	enabled, with reasoning_effort medium	enabled, and the model automatically determines whether to think

Las especificaciones se transcriben de la documentación de cada proveedor; si un proveedor no publica un dato, la fila se omite en vez de deducirlo. Fuentes completas: Dola Seed 2.0 Lite · GLM-5.1

Un mismo prompt en los dos modelos, medido a través de la pasarela

Razonamiento para un CFO Corregir una función con errores Extraer a un esquema Escribir con restricciones

PROMPT Explain to a CFO, in exactly three sentences, why our LLM bill doubled after we enabled reasoning. COMPROBACIÓN exactamente 3 frases

Dola Seed 2.0 Lite superado · 3 sentences

Enabling reasoning on our production LLM requires the model to run resource-intensive multi-step chain-of-thought inference for every customer-facing query, rather than the single-pass inference that powered our original non-reasoning deployment, and GPU compute—which makes up 90% of our total LLM bill—scales directly with the number of compute cycles each query consumes. Our cloud provider’s LLM billing model charges per million processed tokens, and reasoning workflows generate an average of 2.1x more hidden processing tokens (the intermediate problem-solving steps the model never surfaces to end users) that are still billable, pushing our total monthly token consumption just over double what it was prior to enabling the feature. […]

salida 1306 tok (+1096 razonamiento) latencia 18.2 s

GLM-5.1 superado · 3 sentences

Enabling reasoning shifts the LLM from generating quick answers to producing hidden "chain-of-thought" tokens that systematically explore multiple solution paths before responding. Because billing is based on total tokens processed, these invisible reasoning tokens drastically increase input and output volume per query, often adding thousands of compute-intensive tokens to a single prompt. Consequently, our bill doubled not from higher per-token rates or increased user volume, but from the exponentially deeper computational work required to deliver higher-quality, more reliable outputs.

salida 98 tok latencia 7.8 s

Cumplimiento de la instrucción (exactamente tres frases, se pueden contar), adaptación al público (registro de CFO) y la diferencia de facturación por razonamiento oculto que dejan ver los contadores de tokens de abajo.

PROMPT This function is supposed to return the longest run of consecutive equal items, but callers report it is off by one on single-element inputs and misses runs that end at the last index. Fix it and explain the bug in one paragraph. COMPROBACIÓN la corrección pasa las pruebas

Dola Seed 2.0 Lite superado · 8/8 cases

### Corrected Function ```python def longest_run(xs): if not xs: # Handle empty input edge case return 0 best = cur = 1 # Base run length of 1 for any non-empty single element for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 # Reset run length for the new, different element return best ``` ### Bug Explanation (single paragraph) The original function’s core flaw was that it counted the number of consecutive equal adjacent element pairs, rather than the number of elements in the run itself, leading to all results being off by one, which caused both reported issues: a run of k equal elements only has k-1 consecutive matching pairs, so the original function’s maximum `best` value was always one less than the true element count of the longest run. […]

salida 2620 tok (+2217 razonamiento) latencia 33.2 s

GLM-5.1 superado · 8/8 cases

```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` **Explanation:** The original function initialized `cur` and `best` to `0` and only incremented `cur` when a duplicate was found. This counts the number of *extra* equal items in a run rather than the total run length, so every run is reported as one shorter than it actually is—returning `0` for single-element lists and `L-1` for a run of length `L` (including those ending at the last index). The fix initializes `cur` and `best` to `1` (when the list is non‑empty) and resets `cur` to `1` on a mismatch, so `cur` tracks the full length of the current run and `best` records the true maximum.

salida 3823 tok (+3585 razonamiento) latencia 49.7 s

Si la corrección funciona de verdad (se puede ejecutar), lo densa que es la explicación y la eficiencia en tokens en una tarea acotada.

PROMPT Extract a JSON object with fields {company, quarter, revenue_usd_m, growth_pct, guidance} from this text. Use null for anything not stated; add no other fields. COMPROBACIÓN JSON válido, esquema exacto

Dola Seed 2.0 Lite superado · 5/5 fields, guidance "Formal guidance withheld pending Q4 clos"

{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "Formal guidance withheld pending Q4 close" }

salida 1502 tok (+1439 razonamiento) latencia 20.2 s

GLM-5.1 superado · 5/5 fields, guidance "withheld pending the Q4 close"

```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": "eleven and change", "guidance": "withheld pending the Q4 close" } ```

salida 1091 tok (+1028 razonamiento) latencia 15.2 s

Respeto del esquema (sin campos inventados), tentación de alucinar (la guidance se omite a propósito) y diferencias entre las vías de salida estructurada.

PROMPT Write a 120-word product announcement for an API gateway feature that caches prompts across providers. Forbidden words: "seamless", "unlock", "game-changer", "revolutionize", "empower". Exactly one sentence must be a question. COMPROBACIÓN 120 palabras, 0 palabras prohibidas

Dola Seed 2.0 Lite no superado · 141 words, 0 banned, 1 question

Today we launch Cross-Provider Prompt Cache, a new feature for our Core API Gateway built to cut redundant AI costs and latency for teams routing requests across multiple LLM providers. Many development teams rotate between OpenAI, Anthropic, and Google Gemini to balance performance, cost, and capability, but identical prompts get reprocessed from scratch with every provider switch, wasting tokens and slowing response times. This feature stores validated prompt responses at the gateway layer, so repeat requests pull from cache regardless of which provider they route to, with configurable TTLs and built-in compliance with all major provider data policies. […]

salida 1870 tok (+1695 razonamiento) latencia 23.1 s

GLM-5.1 superado · 120 words, 0 banned, 1 question

We are excited to introduce Prompt Cache for our API Gateway. This new feature stores responses for identical prompts, routing subsequent requests directly to the cache instead of calling the underlying AI provider. Are you tired of paying multiple times for the exact same query? Prompt Cache solves this by recognizing duplicate inputs across all supported providers, drastically reducing latency and operational costs. When a user submits a request that matches a previously cached prompt, the gateway returns the stored answer instantly. You can configure cache expiration and scope rules via your dashboard to maintain data freshness. Stop wasting budget on redundant computational work. Upgrade to the latest gateway tier today to start saving time and money on every call.

salida 3935 tok (+3802 razonamiento) latencia 41.1 s

Respeto de las restricciones (límite de palabras, lista de palabras prohibidas, una única pregunta), sello de estilo y control de la longitud.

Cambia de uno a otro con una sola línea

Los dos ids aparecen en todas las pestañas de abajo; lo único que cambia es el par de líneas resaltadas. El endpoint, la clave y la estructura de la solicitud son los mismos.

from openai import OpenAI

client = OpenAI(
    base_url="https://synthorai.io/v1",
    api_key="sk-syn-...",
)

resp = client.chat.completions.create(
    model="Dola-Seed-2.0-lite",
    # model="glm-5.1",  # descomenta esta línea, comenta la de arriba
    messages=[{"role": "user", "content": "Summarize this diff"}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://synthorai.io/v1",
  apiKey: "sk-syn-...",
});

const resp = await client.chat.completions.create({
  model: "Dola-Seed-2.0-lite",
  // model: "glm-5.1",  // descomenta esta línea, comenta la de arriba
  messages: [{ role: "user", content: "Summarize this diff" }],
});
console.log(resp.choices[0].message.content);

curl https://synthorai.io/v1/chat/completions \
  -H "Authorization: Bearer sk-syn-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Dola-Seed-2.0-lite",
    # "model": "glm-5.1",  # descomenta esta línea, comenta la de arriba
    "messages": [{"role": "user", "content": "Hello"}]
  }'

package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
)

func main() {
	client := openai.NewClient(
		option.WithBaseURL("https://synthorai.io/v1"),
		option.WithAPIKey("sk-syn-..."),
	)
	resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
		Model: "Dola-Seed-2.0-lite",
		// Model: "glm-5.1",  // descomenta esta línea, comenta la de arriba
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage("Summarize this diff"),
		},
	})
	fmt.Println(resp.Choices[0].Message.Content)
}

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .baseUrl("https://synthorai.io/v1")
    .apiKey("sk-syn-...")
    .build();

ChatCompletion resp = client.chat().completions().create(
    ChatCompletionCreateParams.builder()
        .model("Dola-Seed-2.0-lite")
        // .model("glm-5.1")  // descomenta esta línea, comenta la de arriba
        .addUserMessage("Summarize this diff")
        .build());
System.out.println(resp.choices().get(0).message().content().orElse(""));

Obtén tu clave API →

Preguntas frecuentes

¿Cuál es más barato, Dola Seed 2.0 Lite o GLM-5.1?

Dola Seed 2.0 Lite es más barato en Entrada / 1M tokens ($0.25 frente a $1.4, una diferencia de 5.6×). En otras filas puede ser al revés: la tabla de arriba recoge todas las tarifas, y el coste real depende de tu combinación de uso.

¿Puedo hacer pruebas A/B de Dola Seed 2.0 Lite frente a GLM-5.1 sin dos integraciones?

Sí. Los dos se sirven desde el mismo endpoint compatible con OpenAI y con una sola clave API. Para cambiar de uno a otro basta con tocar una línea, el nombre del modelo, así que puedes mandar una parte del tráfico a cada uno y comparar directamente las facturas.

¿Admiten Dola Seed 2.0 Lite y GLM-5.1 caché de prompts?

Sí. Los dos cobran las lecturas de caché por debajo de su tarifa de entrada, así que las cargas de trabajo que reutilizan un prefijo ya cacheado cuestan menos de lo que sugieren los precios de lista. Las tarifas exactas de lectura de caché están en la tabla de precios de arriba.

Comparativas relacionadas

Dola Seed 2.0 Lite vs GPT-6.1 Sol Dola Seed 2.0 Lite vs Claude Sonnet 5.5 Dola Seed 2.0 Lite vs GPT-6 Sol Dola Seed 2.0 Lite vs GPT-6 Luna Compara dos modelos cualesquiera →