Commitments you can verify yourself.

One open model class, served fast and deterministic. Providers compete on price and speed; this API competes on something you can check: determinism, an honest meter, and a pinnable build. Every commitment on this page ships with the recipe to run that check from your own client — you never have to take our word for it.

Get an API key Verify it yourself

OpenAI SDK compatible · free evaluation credits · keys are issued by manual review — usually within a day

tiyuvta — /v1/chat/completions

curl python response

curl https://api.tiyuvta.ai/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.6-27b",
    "messages": [{"role": "user", "content": "hello"}],
    "seed": 7
  }'
# same seed, same tokens — run it twice

from openai import OpenAI

# change one line
client = OpenAI(base_url="https://api.tiyuvta.ai/v1")

r = client.chat.completions.create(
    model="qwen3.6-27b",
    messages=[{"role": "user", "content": "hello"}],
    seed=7,  # same seed, same tokens — run it twice
)

{
  "model": "qwen3.6-27b",
  "system_fingerprint": "memra-<git-sha>",  # pin this
  "choices": [{ "message": { "content": "…" } }],
  "usage": {                    # worker-truth counts
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "prompt_tokens_details": { "cached_tokens": 0 }
  }
}
# the shape — run the curl tab for real values

170.5 tok/s single-stream, spec decode, through the serve surface (186.7 bare CLI), c=1, N=5 median — RTX PRO 6000, rented pod
0.182 s / 0.003 s TTFT cold / warm — cold forced with a fresh cache_salt per request; warm = prefix-cache hit
464,870 req · 0 errors 140-minute soak, 8 replicas (9B class, rented H100s), 0 sheds; a greedy probe hashed identical on all 8 replicas before and after
same tokens, alone or batched greedy output byte-identical whether a request runs alone or inside a full batch (c=1 vs c=16, same server, 16/16 on four models)

fig. 01 — what we commit to, and how you check

Same seed, same tokens — alone or inside a full batch

Check it: send the same request twice with the same seed and diff the output. Then send it again during a load burst and diff again.

Why it holds: gated by replaying the same prompts at c=1 and c=16 against the same server and byte-comparing every stream — 16/16 on four models, at defaults.

the isolation contract →

An honest meter

Check it: compare usage.prompt_tokens_details.cached_tokens against your own prompt. Abort a stream mid-flight and watch it billed to the abort point, not the full request.

Why it holds: token counts come from the worker that did the work — on every response shape, streams included.

serve-compat receipts →

A pinnable build

Check it: pin system_fingerprint from any response and you will detect the day the engine changes underneath you.

Why it holds: the fingerprint carries the engine git sha; model ids are pinned and never silently remapped.

envelope contract →

Known bounded exception, stated unprompted: near-tie first-token drift across prime configurations — ~7% of first tokens on a 144-prompt sweep (10/144, every flip at a top-2 margin ≤ 0.70) — documented here.

fig. 02 — your p95 is admission-controlled, and the protection is measured

Your latency is protected by admission control — measured, not promised.

Interactive requests are never preempted and never queue behind bulk work. Under a c=96 bulk flood an unprotected fleet's interactive p95 inflates to 7.15 s; with admission control it holds 3.69 s, and at the tight SLO dial 2.16 s — statistically equal to an uncontended box. Bulk pressure sheds at admission with 429 + Retry-After before it can touch your tail.

The raw sweep — every cell, both dials, the cost side included — is in the receipt.

fig. 03 — measured speed, against ourselves

2.17x

spec decode vs our own plain decode on the SKU (186.7 vs 86.2 tok/s, same run, bare CLI)

2.61x

spec decode on the official Qwen FP8 checkpoint, its own embedded MTP head (128.1 vs 49.0 tok/s — rented 2x5090)

420.6 tok/s

aggregate at c=8, the knee (N=3 median; beyond c=8 latency doubles per step for no throughput gain)

Conditions: RTX PRO 6000 Blackwell 96GB (rented pod), measured 2026-08-04, N=5 / N=3 medians. Speed numbers are self-competition and regression tracking — the ratios are speculative decode against our own plain decode — not a scoreboard. Current honest gaps, including where others are faster, are in the ledger.

fig. 04 — turn 20 answers like turn 2

TTFT stays flat as your conversation grows — even when your client rewrites history.

Agent clients rewrite conversation history between turns (stripping think blocks, compacting tool output), which defeats ordinary prefix caching and forces a full re-prime of the growing conversation every turn. Session affinity resumes the rewritten conversation instead: across a 25-turn replayed agent transcript (13.1k → 14.6k prompt tokens), per-turn TTFT holds at 0.53–0.65 s where the same engine with the feature off climbs to 11.3–14.0 s.

The safety rule is the same exactness posture as everything else: identity only nominates a candidate session — the bytes decide. Your prompt must reproduce the session's committed tokens exactly, or the whole thing re-primes. A collision costs one wasted comparison, never someone else's context.

Measured on RTX 5090 Laptop, owner's daily serve config, N=3 interleaved. The comparison is against our own engine with the feature disabled — a cold first turn gains nothing (1.01x), and this does not change our documented cold-TTFT gap.

fig. 05 — built for workloads where outputs are compared

Eval and regression pipelines

If your suite diffs model output across runs, nondeterminism is noise in your signal. Same seed, same tokens — alone or inside a full batch — means a failed eval is a real regression, not batch roulette. Pin system_fingerprint and the engine cannot change under your baseline unnoticed.

Agent loops that replay history

Agent clients rewrite conversation history between turns, which defeats ordinary prefix caching. Session affinity keeps TTFT flat across a growing conversation — turn 20 answers like turn 2 — and the honest meter bills aborts to the abort point.

Anyone who audits the bill

Worker-truth token counts on every response, cached tokens itemized per request. If you reconcile usage against invoices — or resell capacity and need the meter to hold up — the numbers are checkable from your own logs.

Where this is the wrong fit, said plainly: if you need the cheapest bulk tokens on the market or a hundred-model menu, larger providers win — the ledger keeps our documented gaps public, including where others are faster.

built in the open

avifenesh/memra

The engine is public: a from-scratch Rust+CUDA inference server, MIT licensed, every published number's raw run logs committed in-repo. It is built by tiyuvta, the research lab this product funds.

The evidence, one level up

Every number on this page traces to the lab's evidence ledger — wins and bounded limits both, including the gaps we have not closed yet. That is the point: you can check.

faq

Is it OpenAI-compatible?

Yes — validated against the official openai SDK. The base_url swap is the only change to your code.

What is a verification recipe?

Every commitment on this page ships with the two-request check you run from your own client. No trust required.

What are the rate limits?

Per-key limits, stated at issuance. The rate-limit headers on every response tell the truth about them — including mid-stream.

How fast do I get a key?

Manual review, usually within a day. The request form is short — one question about your workload.

Same seed, same tokens. Check it yourself.

Get an API key Read the docs See pricing