Key takeaways

  • AWS announced the multi-node Ray LLM Deep Learning Container on October 12, 2026. The live catalog identifies serve-llm-cuda-v1.0 as Ray 2.58 with Python 3.13 and CUDA 13.0 for EC2-based deployment.
  • The reference stack serves Qwen3.5-9B through one OpenAI-compatible endpoint while separate g6.8xlarge workers handle prefill and decode. Ray Serve LLM, vLLM, NIXL and the EFA software stack ship in the container.
  • This is infrastructure packaging, not a hosted model API. Operators still create and secure EKS, supply three EC2 nodes, satisfy a 64-vCPU GPU quota, pin capacity to one Availability Zone, load the model and own scaling and incidents.
  • AWS publishes no throughput, time-to-first-token, inter-token-latency, quality or cost comparison showing that disaggregation beats a colocated baseline in this setup. Its approximately 145-to-2-second restart claim concerns checkpoint loading from page cache, not request latency.
  • Trial the image only against a colocated baseline using a pinned digest and real traffic shapes. Verify LIBFABRIC in logs, price every always-on resource, remove unnecessary privilege and keep a rollback path before production use.
01

AWS launched the multi-node Ray LLM container on October 12

Amazon Web Services published the multi-node Ray LLM Deep Learning Container on October 12, 2026. The container assembles Ray Serve LLM, vLLM, NVIDIA’s NIXL transfer library and AWS’s EFA communication stack so a distributed model-serving application can be declared in YAML and exposed through an OpenAI-compatible endpoint.

The live AWS image catalog lists Ray 2.58, Python 3.13 and CUDA 13.0 for the serve-llm-cuda-v1.0 tag. This is a deployable container image rather than a managed token endpoint: there is no new foundation-model ID, per-token tariff, service-level agreement or AWS-operated autoscaling contract in the announcement.

02

The reference splits Qwen3.5-9B across two L4 GPU nodes

AWS’s linked sample deploys Qwen/Qwen3.5-9B on Amazon EKS. One g6.8xlarge worker performs prefill, another g6.8xlarge worker performs decode, and a CPU-only m7i.xlarge node hosts system workloads and the Ray head. Each G6 worker supplies one NVIDIA L4 GPU; the manifest sets bfloat16, a 4,096-token maximum model length, 90% GPU-memory utilization and eager execution.

Prefill processes the prompt and creates the key-value cache. Decode consumes that cache while producing tokens. NIXL transfers the cache between workers through LIBFABRIC over EFA. KubeRay 1.4.0 manages the Ray 2.58.0 service, and build_pd_openai_app presents /v1/models and /v1/chat/completions without a custom request handler.

03

A working image does not remove the distributed-systems boundary

The sample requires an AWS account with billing, AWS CLI credentials, kubectl, eksctl, Helm and envsubst, plus quota for two g6.8xlarge instances—at least 64 vCPUs in the selected Region. GPU workers must remain in one Availability Zone because EFA does not cross AZ boundaries. The scripts also create private subnets, outbound NAT, an EKS control plane, a CPU node and the GPU node group.

The worker container requests one GPU and one EFA interface and runs privileged because the documented NIXL path registers CUDA memory with the network device. That is a meaningful security boundary, not a harmless implementation detail. Teams should threat-model the pod, node and image supply chain; restrict workload identity and network egress; test whether narrower permissions become supported; and avoid mixing unrelated tenants on the same workers.

04

The transport can silently fall back to TCP-speed behavior

AWS warns that omitting backends: ["LIBFABRIC"] lets NIXL default to UCX at TCP speed even when EFA is present. The sample therefore sets FI_PROVIDER=efa and tells operators to inspect worker logs for the instantiated backend. A healthy HTTP response alone does not prove that requests used the intended interconnect.

Make that verification a deployment gate. Record EFA device availability, the NIXL backend, cross-node bandwidth, KV-transfer time and errors before collecting model latency. Alert on pod rescheduling, backend changes and degraded bandwidth, because a silent transport fallback can erase the reason for separating prefill and decode while preserving apparent endpoint availability.

05

AWS has not published the comparison needed to justify disaggregation

The post explains why separating compute-heavy prefill from memory-bandwidth-bound decode can reduce interference and permit independent scaling. It does not publish a colocated baseline, request distribution, concurrency, throughput, time to first token, inter-token latency, tail latency, transfer overhead, output quality or utilization result for the reference deployment.

AWS says model-weight loading for Qwen3.5-9B on g6.8xlarge drops from about 145 seconds to about two seconds on restart when the operating-system page cache can retain the roughly 18 GiB checkpoint. That is a provider observation about restart loading under the sample’s memory settings, not a claim that requests become 72 times faster or that the model is production-ready.

06

The bill is infrastructure-shaped, not token-shaped

AWS’s EKS pricing page lists a standard-support cluster at $0.10 per cluster-hour and separately charges for worker nodes and supporting resources. The sample adds two g6.8xlarge instances, one m7i.xlarge instance, storage, NAT and data processing, ECR access, logging and any transfer or public-address charges that apply. Regional capacity and prices vary.

Neither the launch post nor the sample publishes an all-in hourly, per-token or per-accepted-response figure. Price the exact Region and uptime before trial, including idle GPU time and duplicate model memory. Compare it with a colocated configuration and a managed endpoint at the same quality and latency gates; a preassembled container can reduce integration work without reducing the steady-state infrastructure bill.

07

What inference teams should do next

Start with one representative model and traffic trace. Pin the sample commit, resolve the mutable image tag to a digest, record the model revision and license, and run a colocated baseline beside the disaggregated configuration. Measure accepted outputs, time to first token, inter-token latency, p50/p95/p99 completion latency, throughput, KV-transfer time, GPU and network utilization, failures, restart behavior and full cost per accepted response.

Trial when long prompts and decode contention create a measured bottleneck. Constrain rollout to one workload and Availability Zone with explicit capacity, spend, privilege and rollback limits. Wait when EFA capacity, image support or the cost comparison is unresolved. Reject the added topology when transfer overhead, operational burden or idle duplication outweighs the measured gain.

08

Copy-ready multi-node inference launch record

Complete one record per model, image digest, topology and traffic class before moving a disaggregated endpoint into production.

Entries stay in this browser tab and are not submitted to AccessAllGPT. Blank responses are copied as [Unresolved].

Model repository, revision, license and checksums; Ray LLM image URI and digest; Ray, vLLM, NIXL, CUDA, KubeRay and sample commit.

Region, Availability Zone, EKS and Kubernetes versions, head and worker instance types, replicas, GPU memory, storage, subnets, NAT and quotas.

Endpoint schema, model ID, context and output limits, dtype, memory target, batching, concurrency, timeouts, retries and error contract.

EFA devices, FI_PROVIDER, LIBFABRIC log evidence, bandwidth test, KV-transfer time and errors, fallback detection and alerts.

Traffic trace, colocated baseline, repetitions, accepted-output quality, TTFT, inter-token latency, p50/p95/p99, throughput and utilization.

Image provenance, privileged-container review, pod and node isolation, IAM, secrets, model access, egress, tenancy, patches and incident owner.

Current regional rates, cluster and three nodes, NAT, storage, logs and transfer, idle time, support, engineering labor and cost per accepted response.

Trial, constrain, wait or reject; approved workload and traffic ceiling; owner; rollback; expiry; and model, image, price or capacity revalidation triggers.

Primary sources

  1. Run multi-node inference workloads using Ray LLM Deep Learning ContainersAmazon Web Services · Reviewed: October 12, 2026 publication date; launch scope; prefill/decode architecture; bundled inference stack; EKS topology; prerequisites and quotas; RayService configuration; model invocation; EFA verification; deployment timing; cleanup; conclusion and next steps · Retrieved · Supports: AWS announced a Ray LLM Deep Learning Container for multi-node inference and documented a two-GPU-node EKS deployment that separates prefill from decode behind one OpenAI-compatible endpoint.
  2. Ray LLM Deep Learning ContainersAmazon Web Services · Reviewed: Overview; supported platforms and use cases; container components; multi-node serving guidance; image access; version and changelog navigation; security and support documentation links · Retrieved · Supports: AWS documents Ray LLM DLCs as prebuilt containers for distributed LLM serving. The live image catalog lists Ray 2.58, Python 3.13 and CUDA 13.0 under the serve-llm-cuda-v1.0 tag for the EC2 platform.
  3. Multi-Node Ray Serve on EKS sample (commit aacee70)AWS Samples on GitHub · Reviewed: README; environment defaults; immutable repository commit; RayService manifest; Qwen3.5-9B model configuration; Ray and KubeRay versions; g6.8xlarge topology; NIXL and LIBFABRIC settings; privileged worker requirement; deployment, status, invocation, verification and teardown scripts · Retrieved · Supports: The linked AWS sample pins the documented defaults: two g6.8xlarge GPU workers, one m7i.xlarge system node, Qwen3.5-9B, Ray 2.58.0, KubeRay 1.4.0, a 4,096-token maximum model length and the serve-llm-cuda-v1.0 image tag.
  4. Amazon EKS pricingAmazon Web Services · Reviewed: Pricing overview; standard and extended Kubernetes version support; per-cluster fee; worker-node and supporting-resource charges; cross-AZ traffic note; Pricing Calculator; exclusions and regional variability · Retrieved · Supports: AWS lists standard-support EKS clusters at $0.10 per cluster-hour and says customers also pay for worker nodes and supporting resources. The launch post does not provide a complete hourly or per-token price for its reference stack.

Limitations

AccessAllGPT performed a first-party desk review only. We did not receive an AWS account, credentials, credits or support; pull or inspect the container layers; independently audit every sample file; provision EKS, m7i.xlarge or g6.8xlarge nodes; obtain EFA capacity; download or verify Qwen3.5-9B; invoke the API; reproduce the roughly 145-second or two-second loading observations; verify LIBFABRIC; test another model, Region, Availability Zone, context length or replica count; measure request quality, latency, throughput, transfer overhead, security, reliability or cost; inspect an AWS bill; or obtain legal, licensing or compliance advice. The reference is AWS-authored sample code, not a service guarantee. Image contents, tags, repository files, instance availability and prices can change.

Disclosures

AccessAllGPT received no AWS account, credentials, credits, hardware, model files, benchmark data, briefing, review, payment or compensation for this article. AWS, Ray, Anyscale, NVIDIA, vLLM and Qwen did not sponsor, review or endorse it. AccessAllGPT did not test, score or rank the model, image or infrastructure. AccessAllGPT Research is operated by NeuralArc, is independent, and is not affiliated with AWS or organizations cited. Publication-wide relationships are listed on the disclosures page.

Further AccessAllGPT guidance

  1. AWS Publishes a llama.cpp Decision-Model Path for SageMaker AI
  2. Liquid AI Releases d1-3B and d1-omni-600M Decision Models
  3. Ai2 Reworks GPU Scheduling for Large AI Training Clusters
  4. Managed LLM API vs self-hosting
  5. Design an Agent Benchmark That Predicts Production
  6. AccessAllGPT Research methodology
  7. Evidence standards
  8. Publication disclosures

Continue the research

Get evidence-led updates for teams making production AI decisions.