Wafer vs. Baseten

Baseten gives you a platform to configure and deploy model serving yourself on its inference engines, while Wafer runs the tuning loop for you against your own traffic and your TTFT, throughput, and end-to-end latency targets.

Introduction and methodology note

Wafer is an inference platform for performance-sensitive production workloads: products where time to first token (TTFT), output tokens per second (TPS), or end-to-end (E2E) response time decides the user experience or the unit economics. It profiles your real request mix, builds a dedicated endpoint around your model and performance targets, and keeps testing batching, decoding, quantization, engine, kernel, and hardware configurations as traffic changes. It also runs a pay-per-token serverless API, and reports 10T+ tokens of continual inference.

Baseten is an inference and training platform with hosted Model APIs and dedicated deployments you define with a config.yaml, a Python model class, or a custom Docker server. Both serve GLM-5.3 through an OpenAI-compatible API; quantization, context limits, and speeds may differ. They diverge on who does the tuning. Baseten documents engines (Engine-Builder-LLM on TensorRT-LLM, BIS-LLM for large MoE models) and hardware you choose, plus forward deployed engineers. Wafer's continual loop re-tunes the endpoint toward whichever metric you name as traffic shifts.

Methodology. Wafer figures come from Wafer's own published pages, linked inline, and were re-verified on October 29, 2026. Baseten figures come from Baseten's own pricing, docs, and homepage, are stated as plain text, and were re-verified on October 29, 2026. Baseten's dedicated GPU price table did not state its time unit clearly, so those rates are not quoted. TTFT, TPS, and E2E claims are self-reported by each vendor or by customers who measured them, usually on different models. Test both on your own prompts, output lengths, and concurrency.

TL;DR

• On GLM-5.3 list prices, Wafer charges $0.22 input and $3.39 output per 1M tokens against Baseten's $1.40 and $4.40, about 65% less per typical request, and about 76% less than Baseten's GLM-5.3 Fast SKU (derived below).
• Wafer publishes LLM TTFT, TPS, and throughput-under-load figures (for example, about 15,000 tok/s per node at TTFT p95 under 4 s); Baseten's published customer figures cover embeddings and transcription, not LLM TTFT or TPS.
• Choose Wafer when a TTFT, TPS, or E2E target is the requirement and you want the tuning run for you; choose Baseten when you want to own the serving configuration or need to run in your own cloud.

Quick comparison

Where the vendors differ: who runs the tuning

Baseten is ahead on deployment control and breadth: embeddings, transcription, image generation, and text-to-speech run on the same platform. Wafer is lower on GLM-5.3 list price and does not require your team to own the serving configuration.

Per-request cost (derived, GLM-5.3, 10,000 input and 1,500 output tokens, no caching, list prices):

• Wafer: 10,000 x $0.22 / 1M = $0.0022, plus 1,500 x $3.39 / 1M = $0.005085, total $0.007285.
• Baseten GLM-5.3: $0.014 + $0.0066 = $0.0206, so Wafer is (0.0206 - 0.007285) / 0.0206 = 64.6% lower.
• Baseten GLM-5.3 Fast: 10,000 x $2.10 / 1M = $0.021, plus 1,500 x $6.60 / 1M = $0.0099, total $0.0309, so Wafer is 76.4% lower.

Output-heavy runs narrow the gap: at 1,000 input and 5,000 output tokens, Wafer is $0.01717 and Baseten GLM-5.3 is $0.0234, about 27% lower. Reasoning tokens bill as output on both.

Why teams choose Wafer over Baseten

TTFT and throughput published at each load step

Wafer's Qwen3.6-35B-A3B benchmark publishes the curve you would otherwise build yourself on Baseten:

Success stayed at 100% through 50 RPS. On GLM-5.2, Wafer reports 2,626 tok/s per node at 2.4 RPS on a 20K-in, 1K-out workload, at 0.81 s p50 TTFT. Both are Wafer's own measurements.

E2E latency the tuning loop owns

With Baseten you choose the engine and hardware, then re-benchmark as traffic changes. Neon Health handed that to Wafer: p50 client-observed TTFT fell from 800 ms to 550 ms on GLM-5.1 at about 25% higher peak load, against a 600 ms target, with a signed BAA and US-only data residency. Brilliant needs responses in under 2 seconds and reports about 250 ms TTFT and 300+ tok/s, which puts a 300-token reply at about 0.25 + 300 / 300 = 1.25 s E2E (derived). Both are customer-reported.

Same model, lower list price

Wafer's GLM-5.3 input is $0.22 against $1.40 and output is $3.39 against $4.40. Wafer's faster path is a tuned dedicated endpoint, while Baseten's GLM-5.3 Fast is a separate SKU at $2.10 input and $6.60 output.

If a TTFT, TPS, or E2E number is your acceptance test, start a dedicated endpoint benchmark with Wafer and run it against your current Baseten results.

Best use cases for Wafer

Voice agents and real-time assistants

Short turns are TTFT-bound. Wafer tunes p50 TTFT for your traffic and holds it as call volume rises. In YC's voice simulator, GLM-5.2 on Wafer averaged 379 ms LLM latency per turn across 4,168 turns.

How Baseten compares: it publishes sub-300 ms transcription (ClickUp) and lets you choose the engine and hardware for the LLM step yourself.

High-throughput LLM serving

When cost per token tracks tokens per node, Wafer tunes aggregate TPS at your TTFT ceiling. On Kimi K3, a 2.8T-parameter model, Wafer reports 952 tok/s per 8x MI355X node on a 1,024-in, 400-out workload.

How Baseten compares: BIS-LLM targets large MoE models, and you set the throughput configuration.

Coding and agentic products

E2E compounds across agent calls, so tuned prefix caching and speculative decoding matter. Wafer's Responses and Messages endpoints accept Codex and Claude Code style clients.

How Baseten compares: it lists Cursor, Notion, and Vercel among customers and offers a coding-agents guide for Model APIs.

Best use cases for Baseten

Running in your own cloud

Baseten deploys to Baseten Cloud, self-hosted, hybrid, or your VPC, with data residency control and custom regions on Enterprise. If your security team requires inference inside your VPC, that is Baseten's ground.

Multimodal and custom model serving

Baseten covers embeddings, transcription with diarization, text-to-speech, image generation, and compound AI pipelines, and lets you package a custom or fine-tuned model with a Python model class or Docker server.

Platform overview of Wafer

Dedicated endpoints with performance targets

You supply model, traffic shape, and SLO (a TTFT, TPS, or E2E target); Wafer builds the endpoint and keeps optimizing it after launch. Dedicated Inference carries a 99.9% monthly availability SLA with credits of 10%, 15%, or 30%, capped at 40% of the monthly amount, per the SLA page. The public SLA lists no latency target.

Continual inference loop

Wafer profiles whether latency or throughput is limited by scheduling, decoding, kernels, memory pressure, or hardware fit, tests candidates, deploys the measured winner, and repeats. In one DigitalOcean engagement, the loop raised DeepSeek V3.2 aggregate throughput at concurrency 64 from 548 to 2,165 tok/s (internal testing).

Serverless OpenAI-compatible API

The serverless docs list POST /v1/chat/completions, /v1/responses, /v1/messages, and GET /v1/models. Busy models return 429 server_overloaded with Retry-After, and errors can arrive mid-stream, per the errors page.

from openai import OpenAI
client = OpenAI(base_url="https://pass.wafer.ai/v1", api_key="YOUR_WAFER_API_KEY")
r = client.chat.completions.create(model="GLM-5.3",
    messages=[{"role": "user", "content": "Hello!"}], max_tokens=128)

Models and capabilities

The models page documents GLM-5.3: 1,048,576-token context, tools, JSON schema output, n greater than 1, no vision, and reasoning efforts none, low, high, max. Reasoning tokens bill as output and add to TTFT and E2E, so set the effort per route.

Zero data retention

Send Wafer-ZDR: required. Models without support return HTTP 422 model_zdr_not_supported. See the ZDR docs.

curl https://pass.wafer.ai/v1/chat/completions \
  -H "Authorization: Bearer $WAFER_API_KEY" -H "Wafer-ZDR: required" \
  -d '{"model":"GLM-5.3","messages":[{"role":"user","content":"Hi"}]}'

Measuring TTFT, TPS, and E2E on your own prompts

Run the same script against both base URLs. TTFT is time to the first content token; TPS is output tokens over decode time.

import time
t0 = time.perf_counter(); first = None; n = 0
for c in client.chat.completions.create(model="GLM-5.3", messages=msgs,
        stream=True, stream_options={"include_usage": True}):
    if c.choices and c.choices[0].delta.content and first is None: first = time.perf_counter()
    if c.usage: n = c.usage.completion_tokens
end = time.perf_counter()
print(f"TTFT {first-t0:.3f}s  TPS {n/(end-first):.0f}  E2E {end-t0:.3f}s")

How to choose

Switching from Baseten to Wafer

1. Create a Wafer key in the app and add credits.
2. Change base_url and model. Baseten uses zai-org/GLM-5.3; Wafer uses GLM-5.3.
3. Re-run quality and performance tests with the measurement script above, at your real output lengths and concurrency.
4. Add 429 retry handling for server_overloaded.

Before:

client = OpenAI(base_url="https://inference.baseten.co/v1", api_key=BASETEN_KEY)
r = client.chat.completions.create(model="zai-org/GLM-5.3", messages=msgs)

After:

client = OpenAI(base_url="https://pass.wafer.ai/v1", api_key=WAFER_KEY)
r = client.chat.completions.create(model="GLM-5.3", messages=msgs)

What to watch:

• Custom deployments: models you packaged with config.yaml or a custom Docker server need a Wafer engagement; there is no self-serve equivalent on the pages reviewed.
• Hosting location: VPC and hybrid deployment have no Wafer equivalent on the pages reviewed.
• Other modalities: embeddings, transcription, and image models stay on Baseten.
• Partial migration: often best. Keep Baseten for multimodal and in-VPC workloads; move the TTFT-, TPS-, or E2E-critical LLM path to Wafer.

Neon's case states a dedicated endpoint can reach production in under two weeks. That is a stated capability, not a guarantee.

FAQ

Is Wafer faster than Baseten? No same-model LLM benchmark is published by either vendor. Wafer publishes 337 ms single-stream TTFT and 430 tok/s on Qwen3.6-35B-A3B, and its customers report 550 ms p50 TTFT (Neon) and 300+ tok/s (Brilliant). Baseten's published figures cover embeddings and transcription, not LLM TTFT or TPS. Benchmark your own prompts.

Is Wafer cheaper than Baseten? On GLM-5.3 list prices, yes: $0.007285 against $0.0206 for a 10,000-in, 1,500-out request, about 65% lower, and 76% lower than GLM-5.3 Fast at $0.0309. At 1,000 in and 5,000 out the gap against the standard model is about 27%.

What throughput can a Wafer endpoint sustain? Wafer reports about 15,000 tok/s of aggregate output from one 8x MI355X node on Qwen3.6-35B-A3B at TTFT p95 under 4 s, 2,626 tok/s per node on GLM-5.2, and 952 tok/s per node on Kimi K3. All are Wafer's own measurements on different workloads.

Does Baseten have a higher uptime figure? Baseten's homepage says "99.99% uptime out of the box," a marketing claim with no SLA terms reviewed. Wafer's Dedicated SLA is contractual: 99.9% monthly availability with service credits, and no latency target in the public terms.

Does Wafer work with Anthropic and Responses clients? Yes. Wafer serves /v1/messages for Anthropic SDK clients including Claude Code and /v1/responses for Codex-style clients. The Responses endpoint is stateless.

Which hardware does Wafer use? Per its AI info page, NVIDIA and AMD GPUs. Its published benchmarks run on AMD MI355X. Validate availability per model.

Want TTFT, TPS, and E2E numbers on your own traffic? Get started on Wafer and benchmark a dedicated endpoint against your current Baseten results.

Related Articles

• Oct 2026: Wafer vs. Modal
• Oct 2026: Wafer vs. Cerebras