Arctic Platform is a framework for addressing challenges in current post-training frameworks, such as limited support for rapid prototyping and the lack of native data generation tools, by offering modularity across training and inference components, simplified code structures, and integrated pipelines for creating and cleaning synthetic data. These features enable users to enhance LLM capabilities, like code generation and complex reasoning, with greater efficiency and flexibility.
For example in the RL world if one were to compare various frameworks, one will find that each framework implements its own backends, adds fragmented system optimizations and the overall performance isn't quite portable from framework to framework. Thus the intention is to provide consistent building blocks that can be easily integrated into multiple frameworks while providing:
- Unified GPU Backends, e.g. RL on-prem or remote backends
- Unified System Optimizations leading to High Performance Portability
This is a work in progress, starting with the RL components, later integrating more training and inference components.
Arctic Platform aims to cover the full post-training stack for LLMs behind a small, composable API. The codebase is being built out incrementally.
What is available today:
- Arctic Reinforcement Learning — a high-throughput RL training/inference backend that plugs into existing RL frameworks (docs/rl.md).
- ZoRRo Train — a prompt-deduplication optimization that removes redundant prompt computation during RL training (docs/rl.md#zorro-train).
- ZoRRo Inference — forest cascade attention for efficient rollout step that eliminates redundant memory accesses via grouping (docs/rl.md#zorro-inference-forest-cascade-attention).
Full documentation index: docs/index.md (RL, shared server infra; SFT docs forthcoming).
What's coming next:
- additional trainers (SFT/distillation), synthetic data generation and cleaning pipelines, and tighter inference integration.
Arctic RL is designed to integrate into existing RL frameworks rather than replace them. The RL framework keeps ownership of the training loop, rollouts, rewards, and advantage estimation; Arctic Platform provides the heavy compute engines behind a thin client:
- Training engine — a DeepSpeed engine that runs forward/backward and the optimizer step.
- Log-prob / reference engine — a forward-only DeepSpeed engine for reference / old log-prob computation.
- Sampling engine — a vLLM engine with ArcticInference for fast rollouts.
These engines are orchestrated over Ray, can be colocated on shared GPUs (via fractional Ray resources) or split across separate GPUs, and keep the sampler in sync with the trainer through NCCL or CUDA-IPC weight transfer. The RL framework interacts with the compute engines over Ray or HTTP. ArcticInference extends the core optimizations with multi-replica scheduling, load-balancing, weight-sync, and router-replay.
An RL framework integrates this module by constructing a client and driving the standard operations (generate, forward/backward, optimizer step, sync_weights, and wake/sleep for memory management). For example, on a single 8-GPU node one could do:
from arctic_platform.rl import ArcticRLClientConfig, create_arctic_rl_client
config = ArcticRLClientConfig(
model_name="Qwen/Qwen3-4B",
comm_protocol="ray", # or "http"
training_gpus=8, #
sampling_gpus=8,
log_prob_gpus=0,
colocate=True,
)
client = create_arctic_rl_client(config)- Verl. The reference integration is verl (verl-project/verl#6422), which drives Arctic RL from its PPO/GRPO trainer. End-to-end recipes live under recipes/rl/verl, including a simple single-GPU GSM8K starter, Txt2SQL and long-context QA.
Multiple additional frameworks integrations are in the works and will be added here once available. We are in various stages of planning or working on integration into TRL, Axolotl, unsloth, PrimeRL and potentially others.
ZoRRo stands for Zero Redundancy Rollouts.
In RL training (PPO/GRPO) the same prompt is sampled many times to explore different responses, therefore for long sequence tasks 80–95% of the tokens in a batch are redundant prompt tokens — and with transformer attention’s O(n²) cost, recomputing those shared prompts dominates the bill for long-context RL.
ZoRRo Train eliminates that waste with automatic prompt deduplication at all levels: it detects sequences that share a prompt, packs each unique prompt once, runs the model a single time over the deduplicated sequence, and transparently reconstructs per-response logprobs/entropy in the original sample order. The result is mathematically equivalent to the naive forward/backward (gradients match the baseline within numerical precision) while substantially cutting memory use and increasing throughput — the longer and more-shared the prompts, the larger the win.
It is installed transparently by the DeepSpeed training/log-prob engines and toggled per run via ds_worker_config.zorro_train_enable (verl yaml: remote_backend.train.zorro_train.enable). See docs/rl.md § ZoRRo Train.
The supported model families span dense and MoE models - see the list here.
See arctic_platform/rl/zorro_train/README.md for the full design, the deduplication/attention internals, and benchmarks.
During RL rollouts many sequences are generated from the same prompt. In the decode step, standard attention re-reads the KV cache of those shared prefixes once per request, so the sampler spends most of its memory bandwidth fetching identical keys and values over and over.
ZoRRo Inference removes that waste with Forest Cascade Attention (FCA), which deduplicates shared KV reads at the attention layer of the sampling engine. For each decode batch, FCA discovers groups of requests that share a KV-cache prefix. Then it splits each attention call into a single grouped pass over the shared prefix blocks plus a per-request pass over the unique suffix blocks. FCA then reduces the two partial results with rigorous weighting. This reads each shared prefix block once per group instead of once per request, cutting redundant memory accesses while remaining mathematically equivalent to standard attention — the longer and more-shared the prefixes, the larger the win.
It is implemented in the vLLM sampling engine and activates transparently for decode-heavy batches with shared prefixes.
See the Forest Cascade Attention README in Arctic Inference for the full design, the grouping/attention internals, and the tuning knobs.
To get started training a model with Arctic Platform, first install the package, then follow the recipes.
The base install carries the config models only. Pick the extra for the backend you are training against, from PyPI:
pip install "arctic-platform[cortex]" # drive Cortex training over SnowAPI
pip install "arctic-platform[sft]" # run a local training-only server
pip install "arctic-platform[rl]" # ...plus the sampling stack (arctic-inference, vLLM)
pip install "arctic-platform[verl]" # the verl adapter[cortex] is by far the lightest: it skips DeepSpeed, transformers, Ray and vLLM entirely. Importing on-prem code without the matching extra raises an error naming the one to install.
While this project is being very actively developed it's probably better to install directly from git.
To get the latest development version (or to contribute), clone the repository and install it in editable mode:
git clone https://github.com/Snowflake-AI-Research/Arctic-Platform.git
cd Arctic-Platform
pip install -e ".[rl]"In these early days of transitioning to AI-supported projects it's important to communicate to users how AI was used in the code base.
As of this writing the heavy lifting of designing and writing the core was done by humans. The test suite creation and various consistency checking was done by Claude, while super-vised and guided by humans.
If you use Arctic Platform in your research, please consider citing:
@misc{arctic_platform_2025,
title={Arctic Platform: Simplifying and Accelerating Post-Training for LLMs},
author={Snowflake AI Research},
year={2025},
howpublished={\url{https://github.com/Snowflake-AI-Research/Arctic-Platform}}
}Apache License 2.0. See LICENSE.