Kimi K3.1 Pro Highspeed launches on Bedrock with max as the default reasoning effort, Flex tier and explicit caching each with limits
AWS said in a November 10, 2026 blog post that Kimi K3.1 Pro Highspeed is now available on Amazon Bedrock, reusing K3's endpoints and API, with Moonshot AI self-reporting output speed 2–3 times that of K3.1 Pro; a default reasoning effort of max, the latency trade-off of the Flex tier, and explicit caching being unavailable on Converse are the three things to settle before integrating.
What changed
In a machine learning blog post dated November 10, 2026, AWS announced that Moonshot AI's Kimi K3.1 Pro Highspeed is available on Amazon Bedrock. The post describes it as a post-trained version of Kimi K3: it keeps the same 3T-class open-weight architecture and 1 million token context window, and was trained with significantly more post-training compute; according to Moonshot AI, that training targets long-horizon agentic tasks, aims to reduce factual errors, and improves financial modeling, office documents, and coding for game engines, 3D scenes and CAD scripts. Its output token generation rate is higher, and Moonshot AI self-reports a speed 2–3 times that of Kimi K3.1 Pro. On Bedrock it reuses Kimi K3's endpoints, API and features, so applications already running K3 only need to change the model ID; it supports tool calling, structured outputs, configurable reasoning, image input and streaming output, and is reachable through three cross-region inference profiles—global, us and in—with regional data residency requirements determining which profile to choose. AWS says data is processed within its data boundary, is not shared with Moonshot AI and is not used to train models, that zero data retention is always enabled for inference requests, and that operators cannot view prompts or completions during inference. The K3.1 series had been reported before; what is new here is the Bedrock managed channel and the inference and billing options that come with it.
What it means for developers
The practical impact for integrators centers on interface shape and defaults, not on model capability itself. Teams already using the OpenAI SDK can point base_url at the Bedrock runtime endpoint and change the model name, but authentication switches to short-lived bearer tokens generated from AWS credentials; IAM needs InvokeModel and InvokeModelWithResponseStream permissions, and bearer token access also needs CallWithBearerToken. Bedrock offers both OpenAI-compatible Chat Completions and Responses and its own Converse and Invoke, and AWS recommends the former. The second change is that reasoning is maxed out by default: the model always reasons before answering, and takes max when no effort is set, which directly raises latency and output tokens on tasks with small answer spaces such as classification, field extraction and short Q&A; when parsing Converse responses, also pick out the text block, since the response may return a reasoning block first. The third is tiering: AWS says Flex is served at half the Standard price, at the cost of potentially longer response times, and that on-demand quotas are shared across Standard, Priority and Flex, so moving traffic to Flex does not create extra quota out of thin air; the tier is specified per request, and a single application can mix them. The fourth is the caching interface boundary: explicit prompt caching works with Chat Completions, Responses and Invoke, but not with Converse; at least 256 tokens of stable content are needed before a breakpoint, cached content is retained for at least 30 minutes, writes are billed at a rate above standard input, and reads are billed at a discounted rate and do not count toward the per-minute input token quota. For agents and coding assistants that resend system instructions, tool definitions and repository conventions every turn, cache hits often matter more to the bill than unit price. The report also explains why output speed matters more in coding agents: reading files, planning changes, editing code, running tests and fixing failures form a chain of serial calls, each waiting for the previous one to finish, so more output tokens per unit time shortens the whole loop. These are structural changes on the channel side and do not constitute independent verification of model quality.
Integration and evaluation
The following is conditional analysis and advice based on that report; it is recommendation, not verified fact. Decision one: write reasoning effort explicitly into configuration. The report says that when reasoning_effort is not set the default is max, with low, high and max available, and the same setting corresponds to reasoning.effort on Responses. If your workload is classification, field extraction, short Q&A or templated rewriting—tasks with small answer spaces—consider fixing it to low or high by task type and keeping max only on chains that genuinely need multi-step reasoning. The precondition is that you have your own evaluation results by tier rather than lowering it on intuition; if the chain has hard constraints on output format, also confirm that downgrading does not reduce the fields in structured outputs. Measurable criterion: compare pass rates and median output tokens for low versus max on the same set of your own test items; if the pass-rate drop falls within an acceptable range while output tokens fall clearly, put the tier into configuration instead of relying on the default. Decision two: choose the service tier per request and verify which tier actually took effect. AWS says Flex may have longer latency but a lower price, that the tier can be set per request, and that the three tiers share quota. If your work is offline evaluation, batch summarization or background steps in an agent—insensitive to single-response time—you can put a small share of traffic on Flex and keep user-facing synchronous requests on Standard or Priority. The precondition is to confirm with the ServiceTier and ResolvedServiceTier dimensions in CloudWatch which tier actually served the request, because requesting Flex and being served by Flex are two different things, and mixing tiers changes both tail latency and quota consumption. Measurable criterion: p95 latency and cost per thousand tasks for the same batch under Flex and Standard; only expand the share if cost improves and tail latency stays within your timeout budget. Decision three: treat cache availability as an interface selection criterion, not an after-the-fact optimization. Explicit caching is unavailable on Converse, needs at least 256 tokens of stable content before a breakpoint, and retains cached content for at least 30 minutes. If your service is already built on Converse and its context contains long stable prefixes (system instructions, tool definitions, repository conventions), you face a choice between switching to Chat Completions or Responses to gain explicit caching and accepting automatic caching alone: the former can raise hit rates at the cost of changing the call path and accepting that cache writes are billed at a higher rate. Measurable criterion: first read back the cached token count in usage to confirm hits are above zero, then compare input cost and time to first token before and after enabling it, and confirm that hit rates do not collapse noticeably after slight adjustments to breakpoint placement. One more item is worth settling during architecture review: the global profile costs less per token than geographic profiles, but with data residency requirements you can only choose us or in, and changing this after launch affects deployment topology. If you already run workloads on Kimi K3 on Bedrock, the minimal verification is to keep a set of tasks and run them against both K3 and Highspeed in parallel, comparing per-task completion time and failure retries rather than just first-packet speed.
Limits and open questions
Two uncertainties should be preserved. First, the 2–3x figure is Moonshot AI's self-reported speed; the AWS blog gives no benchmark, measurement method or concurrency conditions, and the real gap depends on output length and the tier used, so it cannot be treated as an independently reproduced conclusion. Second, the phrase '3T-class open-weight architecture' describes the architecture, while what Bedrock delivers is a managed inference service: whether the weights can be downloaded and under what license cannot be inferred from that sentence and needs Moonshot AI's official release and license text; even if weights can be downloaded, open weights do not equal an open-source license. There is another easy confusion: per the original text, more post-training compute, fewer factual errors, and improved professional capabilities in financial modeling, office documents, game engines, 3D and CAD scripts are described relative to Kimi K3; between Highspeed and non-Highspeed K3.1 Pro, the difference given here is mainly the output token generation rate, and the article provides neither an item-by-item capability comparison of the two nor independent evaluation data for Highspeed. The cache retention figure gives only a lower bound of 30 minutes, no upper bound, and the Flex latency cost is described only qualitatively. Supported regions, quotas and prices should be checked against Bedrock's model card, region availability page and pricing page, which change over time; the site catalog had an entry with the same name at the time of this check, and its price and quota can be found on the site's pricing page, but catalog inclusion and the Bedrock launch are two independent matters, and the former does not verify the latter.
Illustrations from the original report

