Sky-T1 Guide: Training an o1-Level Reasoner for $450

The Million-Dollar Barrier to Frontier Reasoning Models

When OpenAI unveiled the o1 series in late 2024, it demonstrated a decisive paradigm shift in artificial intelligence: scaling test-time compute through long internal chains of thought allows language models to self-correct, explore multiple problem-solving hypotheses, and achieve super-human benchmarks across mathematics, competitive programming, and doctoral-level scientific reasoning. However, the proprietary nature of these closed systems erected substantial barriers for the broader AI research community and enterprise engineering teams:

1. Closed Weights and Opaque Architectures: Proprietary commercial providers obfuscate reasoning tokens behind high-level summaries or API walls, withholding the underlying datasets, token-level mechanics, and loss formulations that drive reflection and backtracking.
2. Prohibitive Capital Requirements: Replicating frontier reasoning was widely believed to require millions of dollars in compute budgets, massive reinforcement learning infrastructure (PPO/GRPO on thousands of GPUs), and colossal synthetic data pipelines.
3. Data Pollution in Open Post-Training: Early open-source attempts to reproduce reasoning frequently scraped unverified synthetic outputs from public web forums, leading to degenerative repetition, format collapse, and ungrounded hallucinations during extended deliberation.

For organizations developing mission-critical production pipelines—such as extracting financial filings via automated web scraping or orchestrating structured data processing through real-time data fetching—relying solely on closed, expensive APIs introduces crippling unit economics, latency bottlenecks, and strict data privacy concerns.

Can the global open-source community reproduce genuine o1-preview class reasoning on a modest academic budget without spending millions of dollars?

Enter Sky-T1: The $450 Open-Source Recipe from UC Berkeley

In January 2025, researchers from the NovaSky team at the UC Berkeley Sky Computing Lab published Sky-T1: Train your own O1 preview model within $450 along with the open-source SkyThought framework.

The Berkeley researchers proved that democratizing frontier-level reasoning does not require tens of thousands of GPU hours. By rigorously curating a high-signal dataset of 17,000 multi-step reasoning demonstrations (Sky-T1_data_17k) and fine-tuning an open 32B foundation model (Qwen2.5-32B-Instruct), Sky-T1 achieved performance competitive with OpenAI o1-preview on benchmark evaluations:

• MATH500: Matches or exceeds proprietary baselines with high-accuracy symbolic verification.
• AIME 2024: Solves complex Olympiad-level mathematics, achieving a substantial leap over base open-weight models.
• LiveCodeBench & GPQA Diamond: Demonstrates robust cross-domain generalization across competitive programming and graduate-level scientific reasoning.
• Total Training Cost: Completed in approximately 17 hours on an 8x NVIDIA H100 GPU cluster, amounting to less than $450 in total cloud compute costs.

The Core Architectural Tenets of Sky-T1

1. Strategic Seed Selection Over Sheer Volume: Rather than compiling hundreds of thousands of low-difficulty question-answer pairs, Sky-T1 curates 17,000 elite problems where intuitive, zero-shot leaps consistently fail.
2. Explicit Deliberation Tags (<think> ... </think>): The model is trained to encapsulate its internal monologue within structural tags, cleanly separating hidden cognitive search from the customer-facing final answer.
3. Sequence Packing and Memory Optimization: By packing multiple short and medium sequences into 16,384-token windows and leveraging DeepSpeed ZeRO-3 parameter sharding, the training run achieves near-linear GPU scaling and eliminates idle padding overhead.

Dataset Architecture: Anatomy of Sky-T1_data_17k

The foundation of Sky-T1’s efficiency is its meticulously curated dataset: Sky-T1_data_17k. Released publicly on Hugging Face, the dataset balances domain coverage across mathematics, algorithmic programming, and scientific inference.

Domain Composition of the 17K Dataset

The 3-Tier Data Filtration Pipeline

To guarantee that every gradient update reinforces genuine problem-solving rather than rote memorization, NovaSky applied a 3-tier filtering pipeline:

1. Triviality Pruning: Any problem solvable by a standard non-reasoning base model (like vanilla Llama-3-8B in a single pass) was discarded. Only problems requiring non-linear derivation remained.
2. Structural Formatting and Normalization: Traces were normalized into a uniform schema:
   <|im_start|>user [Problem Prompt] <|im_end|> <|im_start|>assistant <think> [Exploratory Thought Steps, Sanity Checks, Backtracking] </think> [Final Answer / Verified Code] <|im_end|> Copy
3. Length and Verification Filtering: Trajectories shorter than 1,000 tokens were filtered out unless representing concise formal proofs. Solutions that failed programmatic test cases (in Python) or symbolic equivalence verifiers (in SymPy) were purged.

Production Implementation: Data Loader, Sequence Packing, and ZeRO-3 SFT

To demonstrate how engineering teams can implement and customize the Sky-T1 recipe, we provide an end-to-end PyTorch implementation featuring:

1. The ReasoningDatasetPacker that packs variable-length <think> reasoning sequences into fixed attention windows without cross-contamination.
2. The MaskedCausalCrossEntropyLoss module that computes loss exclusively on the assistant’s reasoning and answer tokens while ignoring user prompts.
3. The DeepSpeed ZeRO-3 configuration file necessary to train 32B parameter models on an 8x H100 cluster within the $450 budget.

DeepSpeed ZeRO-3 Configuration for 32B Model SFT

To train a 32-billion parameter model across 8x H100 GPUs without out-of-memory (OOM) errors, Sky-T1 utilizes DeepSpeed ZeRO-3 with CPU parameter offloading and gradient checkpointing:

Deep Dive: Block-Diagonal Attention and Sequence Packing Mechanics

In standard supervised fine-tuning pipelines, training on long reasoning sequences of varying lengths introduces massive computational waste. For example, if sequence lengths in a batch range from 1,200 to 14,000 tokens, standard padding extends all sequences to 14,000 tokens. As a result, up to 70% of the attention matrix is occupied by padding tokens that contribute zero gradient signal while consuming substantial GPU VRAM.

To overcome this, Sky-T1 employs sequence packing with block-diagonal attention masking:

1. The Packing Concatenation: Multiple independent problem-solution pairs $(x_1, y_1), (x_2, y_2), \dots, (x_m, y_m)$ are concatenated into a single continuous token buffer of length $L_{\text{max}} = 16,384$: $$S_{\text{packed}} = [x_1 \circ y_1 \circ x_2 \circ y_2 \circ \dots \circ x_m \circ y_m]$$

2. Block-Diagonal Attention Mask: To ensure that token generation in sample $k$ cannot attend to or leak information from sample $j$ (where $j eq k$), the attention matrix $A \in \mathbb{R}^{L_{\text{max}} \times L_{\text{max}}}$ is constrained to a block-diagonal causal structure: $$A_{u, v} = \begin{cases} 0, & \text{if } u \ge v \text{ and } \text{SampleID}(u) = \text{SampleID}(v) \ -\infty, & \text{otherwise} \end{cases}$$

By passing cumulative sequence length offsets (e.g., using FlashAttention-2’s cu_seqlens parameter), the underlying CUDA kernels execute attention only within each sample’s distinct boundary. This achieves a 3.4x throughput acceleration over padded batching, enabling the complete 17k dataset to finish in under 17 hours on 8x H100 GPUs.

Case Study: Algorithmic Deliberation on Competitive Programming

To understand how Sky-T1 approaches complex software engineering challenges, consider how the model resolves a challenging algorithmic problem from TACO / Codeforces involving dynamic programming with bitmask state optimization:

Problem Statement: Given a directed acyclic graph (DAG) with $N \le 20$ vertices and weighted edges, determine the minimum cost path that visits a designated subset of $K \le 15$ mandatory milestone vertices.

1. The Flawed Baseline Approach (Premature Greedy Formulation): Standard non-reasoning instruction-tuned models frequently emit an immediate, flawed topological greedy solution:

“We can sort the vertices topologically and maintain the minimum distance to each milestone vertex using Dijkstra’s algorithm. Because the graph is a DAG, this runs in $O(V + E)$ time.”

This baseline fails because visiting a subset of mandatory vertices in optimal order requires traveling through intermediate non-milestone nodes, rendering simple single-source Dijkstra insufficient.

2. The Sky-T1 Deliberation Trajectory: Sky-T1 initiates explicit self-reflection within the <think> environment:

“<think> Let’s analyze the constraints: $N \le 20$ and $K \le 15$. Notice that $K$ is small ($K \le 15$). This strongly hints at an exponential parameterization in $K$, such as dynamic programming with bitmask. Can we run all-pairs shortest paths first? Because $N \le 20$, running Floyd-Warshall takes $O(N^3) = 20^3 = 8,000$ operations, which executes in under 1 millisecond. Let dist[u][v] be the shortest path from vertex $u$ to vertex $v$. If there is no path between two milestone vertices, dist[u][v] = infinity. Now, we define a bitmask DP state: Let dp(mask, last_milestone) be the minimum cost to have visited the subset of milestones represented by mask, with the current location at last_milestone. Number of states: $2^K \times K$. For $K = 15$, $2^{15} = 32,768$ states, and $32,768 \times 15 \approx 4.9 \times 10^5$ entries. Transitions: From (mask, u), we can transition to any unvisited milestone $v$ (where the $v$-th bit in mask is 0): next_mask = mask | (1 << v) new_cost = dp(mask, u) + dist[milestones[u]][milestones[v]] Total complexity: $O(N^3 + K^2 \cdot 2^K)$. For $N=20, K=15$, $15^2 \times 32,768 \approx 7.37 \times 10^6$ operations, which easily runs well within standard 1.0s time limits! Wait, let’s verify edge cases:

• What if some milestone vertices are unreachable?
• What if $K = 1$? The cost should be 0 if the path starts at that milestone.
• Does the path have a fixed starting node $S$, or can we begin at any arbitrary milestone? Let’s re-read the prompt: ‘starts at vertex 0 and visits all $K$ milestones’. Therefore, initial state is dp(1 << start_idx, start_idx) = dist[0][milestones[start_idx]]. Let’s synthesize the final verified implementation with these safeguards. </think>

def min_cost_milestone_path(n, edges, milestones, start_node=0): INF = float('inf') dist = [[INF] * n for _ in range(n)] for i in range(n): dist[i][i] = 0 for u, v, w in edges: dist[u][v] = min(dist[u][v], w) # Floyd-Warshall for k in range(n): for i in range(n): for j in range(n): if dist[i][k] + dist[k][j] < dist[i][j]: dist[i][j] = dist[i][k] + dist[k][j] k_len = len(milestones) dp = {} for i, m in enumerate(milestones): if dist[start_node][m] < INF: dp[(1 << i, i)] = dist[start_node][m] for mask in range(1, 1 << k_len): for last in range(k_len): if not (mask & (1 << last)) or (mask, last) not in dp: continue curr_cost = dp[(mask, last)] for nxt in range(k_len): if not (mask & (1 << nxt)): nxt_mask = mask | (1 << nxt) nxt_cost = curr_cost + dist[milestones[last]][milestones[nxt]] if nxt_cost < dp.get((nxt_mask, nxt), INF): dp[(nxt_mask, nxt)] = nxt_cost full_mask = (1 << k_len) - 1 ans = min([dp.get((full_mask, last), INF) for last in range(k_len)] + [INF]) return ans if ans < INF else -1 Copy

This transparent deliberation loop guarantees that algorithmic solutions satisfy time and space complexity constraints before committing to code generation.

Test-Time Scaling: Consensus@k and Length Regularization

A pivotal insight from the NovaSky research is how post-trained reasoning models behave under test-time compute expansion. The researchers evaluated Sky-T1 across two orthogonal scaling strategies:

1. Majority Voting (Consensus@k): By sampling $k$ independent reasoning trajectories from Sky-T1 at temperature $T = 0.7$ and taking the majority consensus answer:

• Consensus@1 (greedy single-pass): 88.2% on MATH500.
• Consensus@8: 91.4% on MATH500 (+3.2% gain).
• Consensus@32: 93.6% on MATH500, rivaling full-scale DeepSeek-R1 and OpenAI o1.

2. The Length Penalty and Over-Thinking Hazard: Unlike standard models where longer answers generally correlate with higher accuracy, unconstrained reasoning models can exhibit “over-thinking”—wandering into circular philosophical reflections on simple arithmetic problems. Sky-T1 counters this by:

• Enforcing concise termination tokens when intermediate verification confirms an invariant.
• Establishing temperature decay ($T \to 0.2$) during final numerical extraction to prevent formatting drift.

Empirical Evaluation and Benchmark Analysis

In UC Berkeley’s formal evaluations, Sky-T1-32B-Preview was benchmarked against leading open-weight models, distilled baselines, and proprietary frontier systems like OpenAI o1-preview.

Benchmark Performance Comparison

Model Architecture	Parameter Scale	Training Compute Budget	MATH500 (Acc %)	AIME 2024 (Acc %)	GPQA Diamond (Acc %)
Qwen2.5-32B-Instruct	32 Billion	Pre-trained Base	79.8%	16.7%	41.4%
NuminaMath-72B-CoT	72 Billion	Massive Cloud ($20k+)	78.4%	23.3%	38.6%
DeepSeek-R1-Distill-32B	32 Billion	Multi-stage RL	92.8%	55.0%	58.2%
OpenAI o1-preview	Frontier MoE	Millions ($$$)	85.5%	40.0%	73.3%
Sky-T1-32B-Preview	32 Billion	Under $450 (< 17 hrs)	88.2%	43.3%	56.8%

Key Analytical Takeaways

1. Surpassing OpenAI o1-preview on AIME and MATH500: Despite training on only 17,000 examples for under $450, Sky-T1-32B-Preview outperforms OpenAI o1-preview on the AIME 2024 competition benchmark (43.3% vs. 40.0%) and achieves 88.2% on MATH500.
2. Outperforming Models 2x Larger: Sky-T1-32B outperforms NuminaMath-72B across all reasoning evaluations, illustrating that high-signal data curation with explicit <think> deliberation tags is far more impactful than raw parameter scaling.
3. Remarkable Compute Economics: Prior SFT runs for large reasoning models typically cost tens of thousands of dollars. Sky-T1 proves that sequence packing, ZeRO-3 distribution, and data curation lower the replication threshold to under $450, making high-level reasoning research accessible to any startup or academic lab.

Enterprise Integration and Data Flywheels with AI Fetchly

For enterprise teams deploying domain-specific reasoning agents, Sky-T1 provides a clear, cost-effective blueprint. Instead of relying on closed commercial APIs with unpredictable price changes and latency, organizations can build custom reasoning agents tailored to internal datasets.

1. Generating Enterprise Domain Training Data

Organizations can replicate the Sky-T1 17k recipe for specialized corporate domains:

• Use automated web scraping to collect technical manuals, legal statutes, and regulatory updates.
• Employ real-time data fetching to capture complex edge-case logs, SQL queries, and financial transaction anomalies.
• Format the collected edge cases into <think>-annotated problem-solving demonstrations, creating a custom 5k-to-15k reasoning corpus.

2. High-Throughput Serving and Cost Optimization

Deploying Sky-T1-32B in enterprise production:

• Serving Engines: Deploy using vLLM or SGLang with Chunked Prefill and PagedAttention to maintain sub-second time-to-first-token (TTFT) across long-context reasoning chains.
• Unified API Routing: Connect enterprise client apps through unified API integration to orchestrate model routing and external tool calls.

For engineering leaders evaluating enterprise infrastructure costs, explore our flexible pricing to calculate throughput and API economics, or consult our developer documentation for complete integration guides and SDKs.

Summary and Key Takeaways

Sky-T1 fundamentally redefines the economics of artificial reasoning:

• Frontier Reasoning is Democratized: Achieving o1-class reasoning no longer requires millions of dollars; UC Berkeley demonstrates that $450 in cloud compute is sufficient when data quality is pristine.
• Curated 17K Traces Outperform Massive Datasets: High-difficulty seed selection, multi-step self-reflection, and programmatic verification yield superior generalization compared to indiscriminate 100k+ SFT corpuses.
• Explicit <think> Scaffolding: Deliberation tags provide structured transparency, enabling automated parsers and human reviewers to inspect intermediate cognitive steps.
• Production Ready: Combined with high-performance data extraction platforms like AI Fetchly, Sky-T1 provides an open, private, and highly cost-efficient foundation for enterprise AI systems.