​
Architectural Overview

ATLAS implements a revolutionary hybrid learning architecture that fundamentally reimagines how AI systems acquire and transfer knowledge. Instead of training separate models for every business domain (requiring massive datasets that rarely exist), we train a Teacher model to master reasoning in mathematics - where logic is clear and data is abundant - then transfer those reasoning skills to solve any business problem. This cross-domain learning breakthrough means a model trained exclusively on math problems can guide agents through CRM workflows, telecom debugging, or any complex business task without domain-specific training. It’s not about teaching facts; it’s about teaching how to think.

​
The Two-Phase Paradigm

​
Phase 1: Offline Foundation Training

Offline training establishes deep, generalizable skills through reinforcement learning: 
Offline RL Training (24-48 hours)
├── SFT Warmup: Base reasoning capabilities
├── GRPO Training: Adaptive teaching skills
└── Output: Teacher model with foundational knowledge
Key Characteristics:
  • Compute-intensive: Minimum 2 GPUs (1 for vLLM, 1 for training)
  • High-quality teaching examples: ~900 carefully curated adaptive teaching demonstrations from Arc-ATLAS-Teach-v0
  • Math-trained foundation: Teacher model trained as expert in reasoning, sequential thinking, and complex problem decomposition
  • Cross-domain transfer: Math-trained reasoning generalizes to debugging, coding, and other analytical tasks
  • One-time cost: Amortized over all deployments

​
Phase 2: Online Optimization

Online optimization adapts pre-trained teachers to specific tasks: 
Online Adaptation (2 hours)
├── Task Analysis: Identify performance gaps
├── Reflective Mutation: Automatic reward engineering
├── Policy Updates: Rapid skill refinement
└── Output: Task-optimized teaching policy
Key Characteristics:
  • Lightweight: ~$10 in API costs
  • Rapid: 2-hour optimization cycles
  • Safe: Maintains non-degradation guarantee
  • Continuous: Improves with deployment

​
Technical Implementation

​
Offline Training Pipeline

The offline phase uses GRPO (Group Relative Policy Optimization) with the following objective: 
def grpo_loss(logits, rewards, reference_logits, beta=0.04):
    """
    GRPO loss combining reward maximization with KL constraint

    Args:
        logits: Current policy outputs
        rewards: Performance improvements from teaching
        reference_logits: SFT baseline outputs
        beta: KL divergence coefficient
    """
    policy_logprobs = F.log_softmax(logits, dim=-1)
    reference_logprobs = F.log_softmax(reference_logits, dim=-1)

    # Reward-weighted policy gradient
    pg_loss = -(rewards * policy_logprobs).mean()

    # KL divergence constraint
    kl_loss = F.kl_div(policy_logprobs, reference_logprobs, reduction='batchmean')

    return pg_loss + beta * kl_loss

​
Online Optimization Loop

The online phase implements reflective mutation for continuous improvement: 
class OnlineOptimizer:
    def __init__(self, teacher_model, student_model):
        self.teacher = teacher_model
        self.student = student_model
        self.skill_capsules = []

    def optimize(self, task_samples):
        for iteration in range(max_iterations):
            # Phase 1: Evaluate current performance
            baseline_score = self.evaluate(task_samples)

            # Phase 2: Generate teaching variations
            teaching_variants = self.reflective_mutation(
                task_samples,
                current_performance=baseline_score
            )

            # Phase 3: Select best teaching strategy
            best_variant = self.select_optimal(teaching_variants)

            # Phase 4: Create reusable skill capsule
            if best_variant.improvement > threshold:
                self.skill_capsules.append(best_variant)

        return self.skill_capsules

​
Empirical Validation

​
Performance Comparison

Training ApproachTime to DeployPerformance GainCostGeneralization
Fine-tuning1-2 weeks+10-15%$1000sPoor
Few-shot promptingMinutes+3-5%~$1Limited
ATLAS Hybrid2 hours*+15.7%~$10Excellent
*With pre-trained teacher models

​
Case Study: Validated Cross-Domain Transfer

Our approach’s effectiveness is validated across multiple benchmarks: Mathematics → Telecom (τ²-bench):
  • Teacher trained only on math problems (Arc-ATLAS-Teach-v0)
  • Applied to telecom troubleshooting without any telecom training
  • Result: 24.0% pass@1 (vs 18.0% for GPT-4.1 and Claude 3.7)
Mathematics → CRM (CRMArena-Pro):
  • Same math-trained teacher
  • Applied to policy compliance tasks
  • Result: 54% task completion (vs ~35% for leading models)
The key insight: The Teacher learns problem decomposition and systematic reasoning from mathematics, skills that transfer universally to any domain requiring analytical thinking.

​
Theoretical Foundation: Cross-Domain Learning

​
The Revolutionary Insight

Traditional approaches require massive datasets for every business domain - data that rarely exists. Our breakthrough is teaching an agent the foundational skill of reasoning itself using mathematics, where logic principles are clear and data is abundant, then transferring that skill to solve any business problem. This cross-domain learning addresses the fundamental constraint in enterprise AI: the scarcity of high-quality, in-domain preference data for complex business tasks.

​
Why Mathematics as the Foundation?

Mathematics was chosen deliberately as the training domain because:
  • Clear correctness: Unlike business tasks, math has verifiable ground truth
  • Abundant data: Thousands of well-structured problems available
  • Pure reasoning: Requires systematic thinking, problem decomposition, and logical flow
  • Complexity gradient: From simple arithmetic to AIME-level competition problems
Our Teacher model trained on ~7,000 math problems achieved 46% accuracy on AIME-25, placing it at top-10 SOTA level and validating its deep reasoning capabilities.

​
The Cross-Domain Transfer Mechanism

The magic happens when this math-trained reasoning transfers to business domains:
  1. Fundamental Skills Transfer: Problem decomposition, logical sequencing, and systematic thinking learned in math apply universally
  2. Domain-Agnostic Reasoning: The Teacher generates “thinking traces” - step-by-step reasoning guides that work regardless of domain
  3. No Domain Fine-tuning Required: The Student agent uses these traces without needing business-specific training

​
Empirical Proof of Transfer

Our results demonstrate unprecedented cross-domain transfer:
  • Math → CRM: 54% task completion on CRMArena-Pro (vs ~35% for leading models)
  • Math → Telecom: 24% pass@1 on τ²-bench (vs 18% for GPT-4.1 and Claude)
  • Critical Accuracy: 69.2% accuracy identifying policy violations when present
This proves that deep reasoning skills learned in mathematics create a universal problem-solving capability.

​
Compounding Intelligence

The hybrid architecture enables “Compounding Intelligence” through:
  1. Skill Accumulation: Each task creates reusable knowledge
  2. Transfer Learning: Skills generalize to related problems
  3. Continuous Improvement: Performance increases with deployment

​
Implementation Guide

​
Setting Up Hybrid Training

1

Offline Foundation

Train or download pre-trained teacher models:
# Option 1: Use pre-trained
huggingface-cli download Arc-Intelligence/ATLAS-8B-Thinking

# Option 2: Train custom (minimum 2 GPUs)
scripts/launch.sh 2 configs/run/teacher_sft.yaml
scripts/launch_with_server.sh 1 1 configs/run/teacher_rcl.yaml
2

Online Optimization

Configure task-specific adaptation:
./scripts/openai_agent_atlas.sh configs/optimize/default.yaml \
  task_samples=your_task_data.json \
  optimization_steps=100 \
  temperature=0.7
3

Deploy Enhanced Model

Integrate optimized teaching into production:
from trainers.prompt_adapter import ATLASGEPAAdapter

adapter = ATLASGEPAAdapter(
    teacher_model=optimized_teacher_generate_fn,
    student_model=your_production_model_generate_fn,
    all_prompts=optimized_prompts
)

​
Advantages Over Alternatives

​
vs. Pure Online Learning

  • More stable: Offline foundation prevents catastrophic forgetting
  • More efficient: Reuses learned skills across tasks
  • More general: Transfers to unseen domains

​
vs. Pure Offline Training

  • More adaptive: Quickly specializes for new tasks
  • Lower cost: Minimal compute for deployment
  • Continuous improvement: Learns from production data

​
Next Steps

Adaptive Teaching Protocol

Understand the two-pass teaching mechanism

Online Learning

Learn how skills accumulate over time

First Experiment

Run your first hybrid training pipeline

Architecture Details

Explore technical implementation

​
References