Snowflake Research

Introduction to Arctic Platform

OverviewAgent View (Markdown)

Overview

Arctic Platform is a modular framework that simplifies and accelerates post-training for large language models through unified GPU backends, optimized compute engines, and integrated pipelines. It offers reinforcement learning components, prompt deduplication, and efficient inference optimizations designed to integrate seamlessly with existing training frameworks.

Introduction to Arctic Platform

Overview

Arctic Platform is a framework for addressing challenges in current post-training pipelines. It provides:

  • Modular architecture across training and inference components
  • Simplified code structures for rapid prototyping
  • Integrated pipelines for creating and cleaning synthetic data
  • Unified GPU backends for consistent performance across frameworks
  • System optimizations with high-performance portability

The platform enables users to enhance LLM capabilities—such as code generation and complex reasoning—with greater efficiency and flexibility. It is designed incrementally, currently focusing on reinforcement learning (RL) components with additional training and inference components coming soon.

Key Components

Arctic Reinforcement Learning

Arctic RL is designed to integrate into existing RL frameworks rather than replace them. Your RL framework maintains ownership of the training loop, rollouts, rewards, and advantage estimation, while Arctic Platform provides the compute engines:

  • Training engine — a DeepSpeed engine handling forward/backward passes and optimizer steps
  • Log-prob / reference engine — a forward-only DeepSpeed engine for reference and old log-prob computation
  • Sampling engine — a vLLM engine with ArcticInference for fast rollouts

These engines are orchestrated over Ray and can be colocated on shared GPUs (via fractional Ray resources) or split across separate GPUs. Weight synchronization is maintained through NCCL or CUDA-IPC transfers.

Example: Setting up Arctic RL on a single 8-GPU node

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)

Integration Status:

  • Integrated: SkyRL
  • In progress: Verl (with end-to-end recipes including GSM8K, Txt2SQL, and long-context QA)
  • Upcoming: TRL, Axolotl, unsloth, PrimeRL, and others

ZoRRo Train

ZoRRo stands for Zero Redundancy Rollouts.

In RL training (PPO/GRPO), the same prompt is sampled multiple times to explore different responses. For long-sequence tasks, 80–95% of the tokens in a batch are redundant prompt tokens. Given transformer attention's O(n²) cost, recomputing these shared prompts dominates computational expense.

ZoRRo Train eliminates this waste through automatic prompt deduplication at all levels:

  1. Detects sequences that share a prompt
  2. Packs each unique prompt once
  3. Runs the model a single time over the deduplicated sequence
  4. Transparently reconstructs per-response logprobs/entropy in the original sample order

The result is mathematically equivalent to naive forward/backward (gradients match within numerical precision) while substantially reducing memory use and increasing throughput. Benefits scale with prompt length and sharing.

ZoRRo Train is installed transparently by the DeepSpeed training and log-prob engines and toggled per run via the RL config (zorro_train.enable). It supports both dense and MoE models—see arctic_platform/rl/zorro_train/README.md for the full design, deduplication internals, and benchmarks.

ZoRRo Inference

During RL rollouts, many sequences are generated from the same prompt. In the decode step, standard attention re-reads the KV cache of shared prefixes once per request, causing the sampler to spend most memory bandwidth fetching identical keys and values repeatedly.

ZoRRo Inference removes this waste with Forest Cascade Attention (FCA):

  1. Discovers groups of requests that share a KV-cache prefix
  2. Splits each attention call into:
    • A single grouped pass over shared prefix blocks
    • A per-request pass over unique suffix blocks
  3. Reduces the two partial results with rigorous weighting

Each shared prefix block is read once per group instead of once per request, cutting redundant memory accesses while remaining mathematically equivalent to standard attention. Benefits scale with prefix length and sharing.

FCA is implemented in the vLLM sampling engine and activates transparently for decode-heavy batches with shared prefixes. For implementation details, tuning knobs, and design insights, see the Forest Cascade Attention README.

Installation

From PyPI

Install the latest released version:

pip install arctic-platform

From Source (Development)

Clone the repository and install in editable mode:

git clone https://github.com/Snowflake-AI-Research/Arctic-Platform.git
cd Arctic-Platform
pip install -e .[rl]

For active development, installing from source is recommended given the project's rapid evolution.

Next Steps

To start training a model with Arctic Platform:

  1. Install the package (see Installation)
  2. Follow the recipes to set up your first training pipeline

Citation

If you use Arctic Platform in your research, please cite:

@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}}
}

License

Apache License 2.0. See LICENSE for details.