What the public pages say, and what they do not
Start with what is written down. AWS's model-choice page lists "Kimi K3.1 Pro (Highspeed)" under Moonshot AI, described as a natively multimodal agentic model with a 1-million-token context window1. That is the only Kimi entry on the page as I read it. I could not confirm whether a plain "Kimi K3.1 Pro" is also offered on Bedrock, so this plan treats "standard" as something you may need to get from Moonshot or another host.
Moonshot's own pages, as relayed in our October roundup, show two products: kimi-k3.1-pro at $2 input, $10 output and $0.20 cached input per million tokens, and a Highspeed variant at $4 and $202. The same guide describes reasoning levels low, high and max with max the default, thinking that cannot be turned off, and weights promised by 4 November with no licence stated2. I have not confirmed whether those weights shipped.
Nothing I read states what "Highspeed" changes. It could be the same weights on reserved or less contended capacity, a different serving stack, speculative decoding, a lower precision, or a tuned checkpoint. Each of those is a different answer to "is it the same model", and each shows up differently in tests. The pricing page lists Moonshot AI among the providers and says pricing depends on modality, provider and model3, but the rate cells did not render in the text I read, so I do not quote a Bedrock rate for Kimi here. Look it up in your own console and enter it before you compare cost.
Highspeed is not Bedrock's Priority tier
Two things get conflated. "Highspeed" is part of a model name. Bedrock's service tiers are a separate setting: Standard, Flex, Priority and Reserved3. AWS describes Priority as a premium tier that puts requests ahead in the queue, priced at the standard rate plus a premium, with up to 25% better output tokens per second than Standard for most models that support it4. You pick a tier per call by adding a parameter to the same inference API4.
That gives you up to four things to compare on Bedrock alone, if the model supports them: Highspeed or not, crossed with Priority or Standard. Check Bedrock's service-tier documentation for which Kimi variants accept which tiers; I could not read it. Whatever the matrix turns out to be, label every result row with the model id and the tier, because a latency gain from the tier will otherwise be credited to the model.
The distinction matters for the decision at the end. A tier changes queueing and priority for the same model. A model variant may change the model. You want to know which one you are paying for.
Why "same model" is the wrong question
Our consistency article lists six places where two hosts serving one model name can diverge: precision, chat template, sampler defaults, context and output limits, tool and JSON features, and runtime batching5. Only the first concerns the weights. A speed variant can differ on any of them, and for an agentic model the likeliest to bite are the last four, which are host software.
So test behaviour, not identity. Replace "is it the same model" with four measurable questions:
- Does Highspeed pass the same checkable tasks at the same rate as standard, beyond run-to-run noise?
- Does it call tools with the same function names, valid arguments and finish reasons?
- Is it faster on the metric your product feels, and by how much, at your concurrency?
- Does the speed pay for the rate, per successful task?
If the answers are yes, yes, yes and yes, the label does not matter. If any is no, you have found a difference that a product page would never have told you.
The protocol
This extends the consistency protocol5 with a speed-tier column and a tool-call suite. No results are published here: this is a design, and the numbers have to come from your traffic.
- Define the arms. At minimum: Bedrock Highspeed, and a standard K3.1 Pro on whichever host serves it (Moonshot, or Bedrock if it lists one). Add one other host of the same model if you plan to fail over to it. Record the model id, region or inference profile, and service tier for each.
- Record what each host states about precision, context, maximum output and feature support, with the date. If a host does not state precision, write that down.
- Measure noise first. Send each prompt five to ten times to one arm, spread across the day. The repeat-to-repeat spread is your noise band. Thinking Machines found 1,000 temperature-0 completions of one prompt produced 80 distinct outputs on a single system5, so a single run per arm proves nothing.
- Run all arms interleaved in time, with the same parameters, the same repeats, and every response stored with its arm.
- Score with checks. Exact answers, schema validity, tool-call correctness, truncation by the length limit, output tokens.
- Report the method with the result: dates, settings, sample sizes, noise band.
Keep the prompt set drawn from your real traffic. A generic benchmark answers a question you did not ask. Because Kimi K3.1 Pro's thinking cannot be switched off and defaults to max effort2, fix the reasoning level explicitly on every arm where the API lets you, and check the host honours it. A host that silently ignores the setting will look faster and worse.
The harness: quality, tool calls and latency in one pass
The script streams each request through an OpenAI-compatible endpoint, measures time to first token and total time, and checks both a plain task and a tool call. Replace the target names with routes or model ids that each point at exactly one arm.
import json, os, time
from openai import OpenAI
client = OpenAI(base_url="https://api.infro.io/v1", api_key=os.environ["INFRO_API_KEY"])
# One target per arm; each pinned to a single host, model id and tier.
ARMS = ["kimi-bedrock-highspeed", "kimi-standard-host-a", "kimi-standard-host-b"]
REPEATS = 8
TOOLS = [{"type": "function", "function": {
"name": "get_invoice",
"description": "Fetch an invoice by id.",
"parameters": {"type": "object",
"properties": {"invoice_id": {"type": "string"}},
"required": ["invoice_id"], "additionalProperties": False}}}]
CASES = [
{"id": "sum", "messages": [{"role": "user", "content": "What is 1847 + 2395? Number only."}],
"tools": None, "check": lambda text, calls: text.strip() == "4242"},
{"id": "tool", "messages": [{"role": "user", "content": "Show me invoice INV-20931."}],
"tools": TOOLS, "check": lambda text, calls: tool_ok(calls)},
]
def tool_ok(calls):
if len(calls) != 1 or calls[0]["name"] != "get_invoice":
return False
try:
return json.loads(calls[0]["args"]) == {"invoice_id": "INV-20931"}
except json.JSONDecodeError:
return False
def run_once(arm, case, repeat):
t0 = time.monotonic()
first = None
text, calls, finish, usage = "", {}, None, None
stream = client.chat.completions.create(
model=arm, messages=case["messages"], tools=case["tools"],
temperature=0, max_tokens=4096, stream=True,
stream_options={"include_usage": True},
)
for chunk in stream:
if chunk.usage:
usage = chunk.usage
if not chunk.choices:
continue
ch = chunk.choices[0]
if ch.finish_reason:
finish = ch.finish_reason
d = ch.delta
if (d.content or d.tool_calls) and first is None:
first = time.monotonic() - t0
text += d.content or ""
for tc in d.tool_calls or []:
slot = calls.setdefault(tc.index, {"name": "", "args": ""})
if tc.function.name:
slot["name"] += tc.function.name
slot["args"] += tc.function.arguments or ""
total = time.monotonic() - t0
out = usage.completion_tokens if usage else None
return {"arm": arm, "case": case["id"], "repeat": repeat, "finish": finish,
"ttft_s": round(first, 3) if first else None, "total_s": round(total, 3),
"output_tokens": out,
"tok_per_s": round(out / total, 1) if out else None,
"passed": case["check"](text, list(calls.values())), "text": text}
with open("highspeed-results.jsonl", "w") as f:
for r in range(REPEATS):
for case in CASES:
for arm in ARMS: # interleave arms in time
f.write(json.dumps(run_once(arm, case, r)) + "\n")Two caveats about the script. First, a thinking model may emit reasoning before any visible content, so "first token" here is the first content or tool-call delta, which is what a user waits for. If your host streams reasoning in a separate field, record that moment too. Second, output tokens include reasoning tokens on most hosts, so tokens per second is only comparable between arms that think for a similar length. Compare end-to-end seconds per task as well.
Reading the four results
Quality. For each prompt, compute the pass rate across repeats per arm. A difference counts only if it exceeds the spread you measured on one arm in the noise step. If Highspeed and standard agree within noise on your suite, that is evidence of equivalence on that suite, not proof of identical weights. Add a few hundred prompts before you act on a gap of a few points.
Tool calls. Parsing is host code, so score it separately: correct function name, arguments that parse as JSON and validate against the schema, no extra calls, and a finish_reason consistent with a tool call. Also test the awkward cases: nested arguments, optional fields, two tools that could both apply, and a tool result fed back for a second turn. Differences between hosts here are common even when plain-text quality matches, and they are the ones that break an agent loop.
Latency. Report p50 and p95 of time to first token and of total time, per arm, per time of day, at the concurrency you will run. A speed variant that helps at 1 request in flight may not help when your own load is queueing. Our measure-time-to-first-token article covers timeouts in more depth. Also record how often finish_reason is length, because a faster arm that truncates earlier is not faster.
Limits. Send one prompt near the long end of your real inputs, and one that asks for a long output, to each arm. A host can serve a shorter window or lower output cap than the model card allows5.
Price: compare cost per successful task
Highspeed costs twice standard on Moonshot's list2; on Bedrock you must read your own rate. Either way the right unit is cost per successful task, not rate per million tokens, because the arms may differ in pass rate and in reasoning length.
Fold in the other price levers. Cached input may bill at a lower rate, so a cold cache after a switch moves cost. Bedrock's Priority tier adds a premium to the standard rate and Flex trades latency for a lower one4. Use your negotiated rates where you have them, not list rates. Our articles on failover and bills and on service tiers cover the mechanics.
When to switch, and when not to
Decide in advance, from the results, with rules like these:
- Move interactive traffic to Highspeed if your p95 time to first content on standard misses a latency target you have already committed to, Highspeed meets it, and quality and tool-call scores are inside the noise band. Keep standard as the fallback.
- Stay on standard for background work, batch-like agents and evaluation runs, where nobody waits. Bedrock's own guidance puts multi-step agentic workflows and model evaluations in the Flex tier's use cases4.
- Do not switch if tool-call validity drops, even if text quality holds. Fix that before you buy speed.
- Try Priority on the standard variant first if its tier is supported and the latency gap is modest; it is a per-call setting you can reverse without changing the model.
- Treat any host or tier as changeable. Re-run a short version of this suite monthly and after any announced change, since a host can alter serving without renaming the model.
Running the comparison through a gateway
If you already send traffic through INFRO, each arm can be a named route with a single target on one of your own connections, as in the consistency article. The request record keeps model, latency, token counts and estimated provider cost per request, so the cost-per-success arithmetic uses real counts, and negotiated rates you have entered feed the estimate. Routing rules can send a small share of one prompt-size class or feature to Highspeed while the rest stays on standard, and the traffic-changes findings flag a model answered by a new snapshot, longer answers or slower responses. INFRO sees request metadata, not answers, so quality scoring stays in your harness.
