Astar: Self-Evolving Industrial AI That Learns from Its Own History to Beat Experts

Introduction

Alibaba and Zhejiang University have developed Astar , a specialized large language model designed to guide the autonomous evolution of industrial AI systems. Unlike general-purpose LLMs that offer generic advice, Astar learns from the target system's own evolutionary history—Git commits, loss curves, and business metrics—to propose optimization directions tailored to the specific codebase and data distribution.

The Core Problem: AI Iteration Depends on Scarce Human Expertise

Industrial AI model iteration differs fundamentally from ordinary software engineering. A single experiment cycle—code change, retraining, offline evaluation—can take hours to days, making exhaustive search infeasible. Teams historically rely on senior algorithm experts' intuition to prioritize which ideas to test. This expertise bottleneck limits iteration speed.

General LLMs (e.g., GPT-5.5, Claude-4.8-Opus) possess broad theoretical knowledge but lack the system-specific “battle scars” needed for practical decisions. Applying their generic suggestions often wastes compute: engineers wait days only to see metrics stagnate or regress.

Astar's Insight: Mine the System's Own Evolutionary History

Every Git commit records what changed and how loss curves and business metrics responded. This constitutes a real-world, feedback-rich “avoidance guide.” Astar's creators treat these scattered records as training data for a model that predicts promising evolution directions.

Four Challenges and Astar's Solutions

C1: Data Too Sparse

Adjacent commits yield few supervised samples. Astar uses pairwise augmentation : pair any two historical experiments (e.g., version 1 vs. version 5), compare their full loss curves, and label the lower-loss version as better. This expands sparse logs into dense training pairs, capturing both short-term tweaks and long-term leaps.

C2: Repository Full of Noise

Most commits are logging, refactoring, or dead-code removal. Astar applies a two-stage filter :

Execution-logic filter : Uses call-graph reachability and AST analysis to strip logging, dead code, and formatting changes.

Evolution-intent filter : An LLM semantically analyzes remaining diffs; changes without a clear optimization intent are discarded.

C3: Search Space Too Large

Optimization directions span architecture, loss functions, optimizers, and countless micro-operations. Astar adopts hierarchical hint generation with three-level labels: high-level direction → sub-module → concrete action . During inference, Astar first picks a macro direction (e.g., “optimizer improvement”), then a module (e.g., “Muon / gradient orthogonalization”), then a specific action (e.g., “gradient denoising”). This structures an otherwise near-infinite space.

C4: Validation Too Expensive

Reinforcement learning requires massive trial-and-error feedback, but real experiments take days. Astar trains a reward model on historical positive/negative samples. Given a proposed evolution plan, the reward model predicts its probability of lowering loss in one second . This proxy enables rapid pre-filtering of candidates and provides cheap RL feedback for exploring novel directions.

Training Pipeline and Performance

Astar undergoes standard three-stage training: mid-training → supervised fine-tuning (SFT) → reinforcement learning (RL) on the curated evolution corpus and reward model.

On a recommendation-system optimization benchmark:

0.6B Astar achieves 54.35% S@1 (single-generation real-execution success rate), surpassing GPT-5.5 (30.71%) and human senior experts (32.29%) .

8B Astar pushes S@1 to 67.86% .

This demonstrates that in vertical engineering decision-making, feeding a model high-quality, system-specific evolutionary history is as critical as scaling generic parameters.

Efficiency Gains

Traditional expert workflow: one idea per week (code + training + evaluation). With Astar's second-level reward-model screening plus automated execution, the per-idea trial cost drops from hours/days to minutes , increasing iteration throughput by 10–100× .

Real-World Deployment: Lazada Core Ad Recommendation

Astar was given full control of Alibaba Lazada's core advertising recommendation system for 20 consecutive fully automated iterations without human intervention. Results:

Offline HitRate@200 +23.6%

Online A/B test: GMV +4.86% , ad revenue +1.82% , with significant lifts in CTR and order volume.

These gains occurred in a mature, heavily optimized production system where further improvements are notoriously difficult.

Case Study: Spectral Denoising for Muon Optimizer

When the team tried introducing the Muon optimizer, its orthogonalization step amplified noise in the recommendation setting. Generic LLM advice: “tune learning rate” or “revert to Adam.” Astar proposed a mathematically grounded fix: apply spectral denoising before orthogonalization , using the Marchenko–Pastur law from random matrix theory to compute a deterministic threshold—signals above are kept, those in the noise bulk are suppressed. This preserved Muon's benefits while eliminating noise amplification, adding zero extra training parameters.

Closed-Loop Evolution and Future Outlook

Astar operates in a continuous loop: Astar proposes → Code Agent implements & runs experiment → results feed back as new training data for Astar . This makes Astar a “living” model whose guidance improves as the system evolves.

The work shifts the paradigm from “humans manually iterate AI” to “humans design meta-AI that guides AI.” Algorithm engineers are freed from tedious tuning to focus on frontier architecture breakthroughs, new business paradigms, and designing smarter evolution flywheels.

Paper:

https://arxiv.org/abs/2608.27287