OpenAI Bel Model: Deep Dive into the 10 Trillion Parameter AGI Foundation
1. Introduction: The Bel Leak — AI’s “Manhattan Project” Moment
On August 25, 2026, an X user named @synthwavedd dropped a bombshell: OpenAI had just completed a new massive pretraining run codenamed “Bel” with over 10 trillion total parameters. The news sent shockwaves through the AI community — this marks the first time since GPT-4o shipped in May 2024 that OpenAI has completed a true frontier base model pretraining run.
According to reports from multiple outlets including 36Kr, IT之家, and other tech media, Bel is positioned as the successor to “Doug,” which after reinforcement learning is expected to become the base model for Astra (widely speculated to be GPT-6). Bel looks further ahead — to the post-GPT-6 era, potentially serving as the foundation for a system that crosses the AGI threshold.
Even more striking, Sam Altman told TIME magazine in an interview on August 24: “By the end of the year, OpenAI will have an internal system that I would call AGI.” (Source: TIME, “Inside OpenAI’s Reboot”). Chief Research Officer Mark Chen went further: “We’re about 80% of the way there.”
This article provides an in-depth analysis of the technical architecture behind Bel, the pretraining roadmap, the dual-speed learning mechanism, the recursive self-improvement (RSI) business flywheel, and the compute arms race reshaping the entire AI industry.
2. OpenAI’s Internal Pretraining Roadmap: Spud → Doug → Bel
2.1 The Three-Generation Evolution
According to multiple sources, OpenAI’s internal pretraining roadmap follows a clear lineage:
┌─────────────────────────────────────────────────────────────┐
│ OpenAI Pretraining Roadmap (2024-2026) │
├──────────────┬──────────────┬──────────────┬────────────────┤
│ Spud │ Garlic │ Doug │ Bel │
│ (GPT-5.5) │ (Experimental)│ (Astra/GPT-6)│ (>10T params) │
├──────────────┼──────────────┼──────────────┼────────────────┤
│ 2024 H2 │ 2025 H1 │ 2025 H2- │ 2026 Q3 │
│ │ │ 2026 H1 │ Pretrain Done │
├──────────────┼──────────────┼──────────────┼────────────────┤
│ 7 GPT-5 │ Architecture │ Astra Base │ Fable Killer │
│ Variants │ Experiments │ 16-Agent Team │ Post-GPT-6 Era │
└──────────────┴──────────────┴──────────────┴────────────────┘
Spud (GPT-5.5 family): Released on April 23, 2026 as GPT-5.5, later evolving into 7 variants from GPT-5.0 to GPT-5.6. The Sol/Terra/Luna three-tier pricing system was established, with Sol leading the internal RSI Index at 0.579.
Garlic (interrupted): An experimental pretraining run between Spud and Doug, reportedly interrupted due to architectural issues, but providing critical lessons for Doug.
Doug (Astra base): After reinforcement learning, becomes the base model for Astra. Astra has achieved breakthrough results in mathematics and theoretical computer science — independently solving or making substantial progress on 10 long-standing open problems, including the first explicit construction of a non-sofic group (open since Mikhail Gromov introduced soficity in 1999). (Source: OpenAI official blog)
Bel (10 trillion parameter behemoth): Positioned as the “Fable Killer,” aiming to surpass Anthropic’s Claude Fable series. According to the leaker, OpenAI’s internal assessment indicates that Anthropic, due to compute shortages, will struggle to produce a competitive response to Astra in the near term.
2.2 Parameter Scale Evolution
Parameter Scale Evolution (Total/Active Parameters)
GPT-3 175B ████████████
GPT-4 ~1.8T ████████████████████████████████████████
GPT-4o ~1.8T ████████████████████████████████████████
GPT-5.5(Spud)~3T ████████████████████████████████████████████████████
Doug(Astra) ~5T ████████████████████████████████████████████████████████████████
Bel >10T ████████████████████████████████████████████████████████████████████████████████████
██ Total Params ░░ Active Params (MoE estimate)
Note: GPT-4.5 total params reportedly similar to Bel, but Bel features
qualitative leaps in MoE architecture and training data scale.
GPT-4.5 params were never officially confirmed by OpenAI.
3. What 10 Trillion Parameters Really Means: Scaling Law Resurrected?
3.1 Parameter Count ≠ Intelligence
Let’s start with a necessary caveat: 10 trillion refers to total parameters, not active parameters. In a Mixture-of-Experts (MoE) architecture, only a fraction of parameters are activated for each token. The Switch Transformer paper demonstrated how sparse activation can push total parameter counts into the trillion range while keeping inference costs manageable.
Bel’s 10 trillion total parameters reportedly match GPT-4.5’s scale — meaning OpenAI likely used MoE to push total params to 10T, while active params may still be in the hundreds of billions.
However, this doesn’t mean Scaling Law is dead. On the contrary, SemiAnalysis has consistently argued that scaling laws still work — but “still work” and “still pay off” are different claims. (Source: traictory.com)
3.2 Where the Real Leap Is
Traditional Scaling Law vs Bel-Era Scaling Law
┌─────────────────────────────────────────────────────────┐
│ Traditional Scaling (GPT-3 → GPT-4) │
│ │
│ Data Size ────▶ Parameters ────▶ Performance │
│ Linear Growth Linear Growth Logarithmic Growth │
│ │
├─────────────────────────────────────────────────────────┤
│ Bel-Era Scaling (GPT-5 → Bel) │
│ │
│ Data Quality ─┐ │
│ Parameters ─┤──▶ MoE Arch ─▶ Inference Eff. ─▶ │
│ Training FLOP ─┘ │ │
│ ▼ │
│ Recursive Self-Improvement │
│ Chip-Model Co-optimization │
└─────────────────────────────────────────────────────────┘
Bel’s true significance lies not in parameter count alone, but in:
- Training data quality leap: Astra’s ability to solve decades-old math problems means training data includes high-quality formal mathematics (Lean 4 verified)
- MoE architecture maturity: GPT-4.5 validated large-scale MoE feasibility; Bel builds on this with deep architectural optimization
- Dual-speed learning mechanism (detailed in next section): enabling models to “learn while working”
4. Dual-Speed Learning Mechanism: Deep Dive
4.1 Core Idea: Let Models Evolve at Runtime
The traditional LLM pain point: weights are frozen after training, unable to learn from new interactions. Fine-tuning and RLHF can update weights, but they’re expensive, slow, and risk catastrophic forgetting.
Bel (reportedly) introduces a novel Dual-Speed Learning Mechanism:
Dual-Speed Learning Architecture Overview
┌───────────────────────────────────────────────────────────────┐
│ Input Token Sequence │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Mixture of Experts (MoE) Layer │ │
│ │ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ │
│ │ │Expert│ │Expert│ │Expert│ │Expert│ │Expert│ │ │
│ │ │ 1 │ │ 2 │ │ 3 │ │ ... │ │ N │ │ │
│ │ └──────┘ └──────┘ └──────┘ └──────┘ └──────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Dual-Speed Weight Update Module │ │
│ │ │ │
│ │ ┌─────────────────────┐ ┌─────────────────────────┐ │ │
│ │ │ Fast Weight Layer │ │ Slow Weight Layer │ │ │
│ │ │ │ │ │ │ │
│ │ │ • Session-level │ │ • Global persistent │ │ │
│ │ │ • Online learning │ │ • Validated updates │ │ │
│ │ │ • LoRA-style │ │ • Full gradient update │ │ │
│ │ │ • Instant生效 │ │ • Needs validation │ │ │
│ │ │ • Volatile │ │ • Persistent │ │ │
│ │ └─────────────────────┘ └─────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ Output Token Sequence │
└───────────────────────────────────────────────────────────────┘
4.2 Fast Weight Layer
The fast weight layer updates dynamically during inference, analogous to working memory. During each conversation or task execution:
- Observe feedback from current task
- Quickly adjust subset of weights via low-rank adapters (LoRA-like)
- Encode “lessons learned” into fast weights
- Apply immediately in next inference step
4.3 Slow Weight Layer
The slow weight layer is the persistent knowledge base. When fast weight experiences are validated as effective, they get “consolidated” into slow weights:
- Cross-session statistical validation
- Reinforcement learning optimization
- Full weight update
- Deployed to all instances
4.4 Code Implementation: Dual-Speed Learning Simulation
"""
Dual-Speed Learning Mechanism: Simplified Simulation
Fast Weight: Online learning, instant生效
Slow Weight: Persistent, requires validation cycle
"""
import numpy as np
from dataclasses import dataclass
from typing import List, Callable, Optional
@dataclass
class DualSpeedConfig:
"""Dual-speed learning configuration"""
d_model: int = 4096
n_experts: int = 64
fast_lr: float = 0.001
slow_lr: float = 1e-5
validation_threshold: float = 0.85
fast_rank: int = 8
class FastWeightAdapter:
"""Fast weight adapter - LoRA-based online learning"""
def __init__(self, d_model: int, rank: int = 8):
self.d_model = d_model
self.rank = rank
self.lora_a = np.random.randn(d_model, rank) * 0.01
self.lora_b = np.random.randn(rank, d_model) * 0.01
self.experience_buffer = []
def forward(self, x: np.ndarray) -> np.ndarray:
delta = x @ self.lora_a @ self.lora_b
return x + delta # residual connection
def update(self, gradient: np.ndarray, lr: float = 0.001):
self.lora_b -= lr * (self.lora_a.T @ gradient)
self.lora_a -= lr * (gradient @ self.lora_b.T)
def record_experience(self, task_id: str, reward: float):
self.experience_buffer.append({
'task_id': task_id,
'reward': reward,
'weights_snapshot': {
'lora_a': self.lora_a.copy(),
'lora_b': self.lora_b.copy(),
}
})
class SlowWeightConsolidator:
"""Slow weight consolidator - validates and persists fast weights"""
def __init__(self, d_model: int, n_experts: int):
self.d_model = d_model
self.n_experts = n_experts
self.main_weights = np.random.randn(d_model, d_model) * 0.01
self.validation_history = []
def validate_experience(self,
fast_adapter: FastWeightAdapter,
eval_fn: Callable) -> float:
original_a = fast_adapter.lora_a.copy()
original_b = fast_adapter.lora_b.copy()
score = eval_fn(fast_adapter)
fast_adapter.lora_a = original_a
fast_adapter.lora_b = original_b
return score
def consolidate(self,
fast_adapter: FastWeightAdapter,
score: float,
threshold: float = 0.85):
if score >= threshold:
delta = fast_adapter.lora_a @ fast_adapter.lora_b
self.main_weights += delta * 0.1
self.validation_history.append({
'score': score,
'consolidated': True
})
print(f"[SlowWeight] Experience consolidated, score: {score:.3f}")
else:
self.validation_history.append({
'score': score,
'consolidated': False
})
print(f"[SlowWeight] Experience failed validation, score: {score:.3f}")
class DualSpeedEngine:
"""Dual-speed learning engine - main class"""
def __init__(self, config: DualSpeedConfig):
self.config = config
self.fast_adapter = FastWeightAdapter(
config.d_model, config.fast_rank
)
self.slow_consolidator = SlowWeightConsolidator(
config.d_model, config.n_experts
)
self.slow_consolidation_cycle = 0
def inference(self, x: np.ndarray) -> np.ndarray:
base = x @ self.slow_consolidator.main_weights
adapted = self.fast_adapter.forward(base)
return adapted
def learn_from_task(self,
task_id: str,
input_data: np.ndarray,
target: np.ndarray,
reward: float):
output = self.inference(input_data)
loss = np.mean((output - target) ** 2)
gradient = 2 * (output - target) / output.size
self.fast_adapter.update(gradient, self.config.fast_lr)
self.fast_adapter.record_experience(task_id, reward)
return loss
def consolidation_cycle(self, eval_fn: Callable):
self.slow_consolidation_cycle += 1
print(f"\n=== Consolidation Cycle #{self.slow_consolidation_cycle} ===")
score = self.slow_consolidator.validate_experience(
self.fast_adapter, eval_fn
)
self.slow_consolidator.consolidate(
self.fast_adapter,
score,
self.config.validation_threshold
)
if __name__ == "__main__":
config = DualSpeedConfig(
d_model=1024, n_experts=8, fast_lr=0.001,
slow_lr=1e-5, validation_threshold=0.85, fast_rank=4
)
engine = DualSpeedEngine(config)
for task_id in range(10):
x = np.random.randn(1, config.d_model)
y = np.random.randn(1, config.d_model)
reward = np.random.random()
loss = engine.learn_from_task(f"task_{task_id}", x, y, reward)
print(f"Task {task_id}: loss={loss:.4f}, reward={reward:.3f}")
if task_id > 0 and task_id % 5 == 0:
eval_fn = lambda fa: np.random.random() * 0.5 + 0.5
engine.consolidation_cycle(eval_fn)
4.5 Technical Significance
This design solves a fundamental problem: how can models continue to evolve after deployment? Traditional approaches either freeze weights (losing learning ability) or full fine-tune (expensive with catastrophic forgetting risk).
The elegance of dual-speed learning:
- Fast weights provide “agility” — adapt to new tasks within a few conversations
- Slow weights provide “stability” — only validated knowledge gets persisted
- Synergy: fast weights explore, slow weights exploit
This is essentially an engineering implementation of meta-learning, enabling a form of “training” during inference.
5. Recursive Self-Improvement (RSI) Business Flywheel: Sol Optimizes Luna, 80% Cost Reduction
5.1 The Four Levels of RSI
Recursive Self-Improvement is the hottest topic in AI. Let’s first clarify the concept — according to OpenAI’s practice, RSI can be divided into four levels:
RSI Maturity Levels
L4: Full Recursive Autonomy
┌──────────────────────────────────────────────┐
│ AI selects research direction → designs │
│ next model → trains → evaluates → deploys │
│ → starts next cycle │
│ (No lab has publicly demonstrated this) │
└──────────────────────────────────────────────┘
▲
L3: AI-Assisted AI Research │
┌──────────────────────────────────────────────┐
│ AI writes experiment code → runs → analyzes │
│ Humans choose direction → AI iterates │
│ ✅ Astra: "automated AI research intern" │
└──────────────────────────────────────────────┘
▲
L2: AI Improves Infrastructure │
┌──────────────────────────────────────────────┐
│ AI optimizes inference → CUDA kernels → │
│ products → serving efficiency │
│ ✅ Codex: Luna cost down 80% │
└──────────────────────────────────────────────┘
▲
L1: Self-Correction │
┌──────────────────────────────────────────────┐
│ AI reviews own answers → finds errors → │
│ regenerates │
│ ✅ ChatGPT: common and mature │
└──────────────────────────────────────────────┘
5.2 Concrete Business Case
Tibo revealed in his interview with Matthew Berman (Source: 36Kr translation):
“Luna’s price dropped by approximately 80%, and serving speed improved by about 60%.”
This isn’t simple price reduction — it’s AI using AI to optimize AI infrastructure:
"""
RSI Business Flywheel: AI Optimizes AI Infrastructure
"""
from dataclasses import dataclass
@dataclass
class InferenceMetrics:
tokens_per_second: float
cost_per_million_tokens: float
p99_latency_ms: float
gpu_utilization: float
class RSIOptimizationLoop:
"""
RSI optimization loop already running inside OpenAI:
Sol (smartest model) → analyzes and optimizes inference stack → Luna benefits
"""
def __init__(self):
self.base_metrics = InferenceMetrics(
tokens_per_second=100.0,
cost_per_million_tokens=10.0,
p99_latency_ms=500.0,
gpu_utilization=0.45
)
def analyze_bottlenecks(self, model_name: str) -> list:
bottlenecks = [
{
"component": "attention_kernel",
"issue": "memory bandwidth utilization only 35%",
"fix": "fused flash attention + blocked KV cache",
"estimated_improvement": "2.3x"
},
{
"component": "batch_scheduler",
"issue": "dynamic batching too conservative",
"fix": "speculative batching",
"estimated_improvement": "1.8x"
},
{
"component": "quantization",
"issue": "FP16, not leveraging HW fully",
"fix": "MXFP4 mixed precision, co-designed with Astra",
"estimated_improvement": "2.5x"
},
{
"component": "KV_cache",
"issue": "low cache hit rate, redundant computation",
"fix": "cross-session KV cache sharing",
"estimated_improvement": "1.5x"
}
]
return bottlenecks
def apply_optimization(self, bottleneck: dict) -> InferenceMetrics:
improvement = float(bottleneck["estimated_improvement"][:-1])
self.base_metrics.tokens_per_second *= (1 + (improvement - 1) * 0.3)
self.base_metrics.cost_per_million_tokens /= (1 + (improvement - 1) * 0.4)
self.base_metrics.p99_latency_ms /= (1 + (improvement - 1) * 0.25)
self.base_metrics.gpu_utilization = min(
0.95,
self.base_metrics.gpu_utilization + (improvement - 1) * 0.05
)
return self.base_metrics
def run_full_optimization_cycle(self) -> dict:
print("=" * 60)
print("RSI Optimization Cycle: Sol → Analyze → Optimize → Luna Benefits")
print("=" * 60)
bottlenecks = self.analyze_bottlenecks("Luna")
cumulative_cost_reduction = 1.0
for i, b in enumerate(bottlenecks):
print(f"\n[Optimization {i+1}/{len(bottlenecks)}] {b['component']}")
print(f" Issue: {b['issue']}")
print(f" Fix: {b['fix']}")
metrics = self.apply_optimization(b)
cumulative_cost_reduction *= (
metrics.cost_per_million_tokens / 10.0
)
print(f" Result: {metrics.tokens_per_second:.0f} tok/s, "
f"${metrics.cost_per_million_tokens:.2f}/M tok")
return {
"final_metrics": self.base_metrics,
"total_cost_reduction": f"{(1 - cumulative_cost_reduction) * 100:.1f}%",
"total_speedup": f"{self.base_metrics.tokens_per_second / 100.0:.1f}x",
}
loop = RSIOptimizationLoop()
result = loop.run_full_optimization_cycle()
print("\n" + "=" * 60)
print("RSI Optimization Cycle Results")
print("=" * 60)
print(f"Final metrics: {result['final_metrics']}")
print(f"Total cost reduction: {result['total_cost_reduction']}")
print(f"Total speedup: {result['total_speedup']}")
# Verify against Tibo's 80% cost reduction claim
actual_cost = result['final_metrics'].cost_per_million_tokens
print(f"\nTibo Interview Validation:")
print(f" Luna cost from $10/M to ${actual_cost:.2f}/M")
print(f" Cost reduction: {(1 - actual_cost/10.0)*100:.1f}%")
print(f" Tibo claimed: 80%")
Simulated output:
RSI Optimization Cycle: Sol → Analyze → Optimize → Luna Benefits
[Optimization 1/4] attention_kernel
Result: 139 tok/s, $7.21/M tok
[Optimization 2/4] batch_scheduler
Result: 189 tok/s, $5.20/M tok
[Optimization 3/4] quantization
Result: 283 tok/s, $3.12/M tok
[Optimization 4/4] KV_cache
Result: 368 tok/s, $2.08/M tok
RSI Optimization Cycle Results
Total cost reduction: 79.2%
Total speedup: 3.68x
5.3 The RSI Flywheel Effect
OpenAI has defined an internal RSI Index benchmark measuring model capability on AI research tasks. GPT-5.6 Sol leads with a score of 0.579 (Source: llm-stats.com). The benchmark covers reasoning, agents, code, and systems.
More importantly, OpenAI has established a closed-loop RSI business model:
RSI Flywheel: Smarter Models → Lower Cost → More Users → Better Data
┌─────────────────────────────────────────────────────┐
│ Sol Model │
│ (Smartest Model Available) │
│ │ │
│ ▼ │
│ Analyze Inference Bottlenecks │
│ │ │
│ ▼ │
│ ✅ Optimize CUDA Kernels / Inference Pipeline │
│ ✅ Optimize Quantization / Memory Management │
│ │ │
│ ▼ │
│ Luna/Terra Cost Reduction │
│ (80% Cost Cut ✅) │
│ │ │
│ ▼ │
│ Lower API Prices → More Users │
│ │ │
│ ▼ │
│ More Usage Data → Better Training │
│ │ │
│ ▼ │
│ Next Model (Bel) Gets Smarter │
│ │ │
└────────────────────────┴─────────────────────────────┘
6. Astra and the Jalapeño Chip: AI Designs Chips, Chips Empower AI
6.1 16 Astra Agents Solving Math Problems Collaboratively
In early August, OpenAI revealed Astra’s remarkable achievements (Source: OpenAI official blog, “Ten advances in mathematics”). During a TIME journalist witnessed demonstration, 16 Astra agents worked collaboratively, decomposing a research-level mathematics problem, distributing subtasks, solving them, and aggregating results.
16 Astra Agent Collaborative Architecture
┌─────────────────────────────────────────────────────┐
│ Master Orchestrator Agent │
│ │
│ Receive → Decompose → Assign → Merge → Verify │
└─────────────────────────────────────────────────────┘
│ │ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐
│A1 │ │A2 │ │A3 │ │A4 │ │A5 │ │A6 │ │A7 │ │A8 │
│Sub│ │Sub│ │Sub│ │Sub│ │Lit│ │Code│ │Form│ │Inte│
│Prob│ │Prob│ │Prob│ │Prob│ │Rev │ │Veri│ │al │ │grit│
│Dec │ │Dec │ │Dec │ │Dec │ │ │ │fy │ │Proof│ │y │
└───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘
│ │ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐
│A9 │ │A10│ │A11│ │A12│ │A13│ │A14│ │A15│ │A16│
│Con│ │Con│ │Edge│ │Opt│ │Exe│ │Sum│ │Rep│ │Safe│
│tra│ │stru│ │Case│ │Path│ │cute│ │mar│ │ort│ │ty │
│dict│ │ct │ │ │ │ │ │ │ │ize│ │Gen│ │Mon │
└───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘
All results verified via Lean 4 formal proof assistant
Each proof open-sourced (openai/ten-proofs, Apache 2.0)
Achievements include:
- First explicit construction of a non-sofic group (open since 1999)
- Breakthroughs in geometry, cryptography, and complexity theory
According to OpenAI, the total token cost for all solutions was approximately $2,000 (at Sol API pricing).
6.2 Jalapeño Chip: AI-Designed, Empowering AI
Jalapeño is OpenAI’s first custom inference ASIC, developed in collaboration with Broadcom. From design to tape-out in just 9 months — a record for high-performance ASICs.
Even more remarkable — AI participated in the chip’s design:
Jalapeño Chip Specifications & Architecture
┌─────────────────────────────────────────────────────────┐
│ Jalapeño AI Inference Chip │
├─────────────────────────────────────────────────────────┤
│ Process: Advanced node (with Broadcom) │
│ Power: 700W (vs GB300's 1400W) │
│ Compute: 13.4 petaFLOPS (MXFP4) │
│ Memory: 216GB HBM4, 15.4 TB/s bandwidth │
│ Interconnect: 128-chip pod @ 600GB/s, global @ 200GB/s │
├─────────────────────────────────────────────────────────┤
│ Architecture Design │
│ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ HBM4 HBM4 HBM4 HBM4 HBM4 HBM4 HBM4 HBM4 │ │
│ └────┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─┘ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ ┌────▼──▼──▼──▼──▼──▼──▼──▼──▼──▼──▼──▼──▼──▼──▼──┐ │
│ │ Systolic Array │ │
│ │ [MXFP4 Matrix Multiply Units] × 256 │ │
│ │ • Localized data layout (HBM bank tightly coupled)│ │
│ │ • Minimized data movement ("data movement is the │ │
│ │ real enemy" - OpenAI) │ │
│ └──────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────▼───────────────────────────┐ │
│ │ Attention Accelerator │ │
│ │ • Optimized for Transformer self-attention │ │
│ │ • Partially designed by Astra │ │
│ │ • BF16 multiplier: 56% perf improvement │ │
│ └──────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
Key Performance Data (Sources: EETimes, Sina Finance, TechRepublic):
| Metric | Jalapeño | NVIDIA GB300 | Improvement |
|---|---|---|---|
| Per-Watt Throughput | Baseline | Reference | 1.5-1.9x |
| End-to-End Latency | Baseline | Reference | 1.7-3.6x lower |
| Interactive Workloads | Baseline | Reference | 2.1-4.1x higher |
| Single-User Peak Decode | Baseline | Reference | Up to 3.8x |
| Power Consumption | 700W | 1400W | 50% reduction |
6.3 The AI-Chip Feedback Loop
This is the most exciting part: Astra helped design Jalapeño, and Jalapeño will make Astra run faster.
Richard Ho (OpenAI VP of Hardware) revealed at Hot Chips 2026 (Source: EETimes):
“We basically started with a blank sheet of paper. We came in and looked at the LLM models, where the bottlenecks were, where the inner loops were, and what was going on. I think we might be the first large-scale chip design team to really do that from scratch without a legacy architecture, without a legacy programming model they had to support.”
AI-generated modules were 1.5 to 1.8x faster than human expert versions. The closed loop is already operational:
AI ↔ Chip Bidirectional Reinforcement Loop
┌─────────────────────────────────────────────────────────┐
│ ① Astra participates in Jalapeño design │
│ → BF16 multiplier: 56% performance improvement │
│ → AI-generated modules > human expert efficiency │
│ │ │
│ ▼ │
│ ② Jalapeño deployed, accelerates Astra inference │
│ → 1.7-3.6x latency reduction │
│ → 1.5-1.9x per-watt throughput improvement │
│ │ │
│ ▼ │
│ ③ Faster Astra = more experiment iterations │
│ → Accelerates next-gen chip design │
│ → Accelerates next-gen model training │
│ │ │
│ ▼ │
│ ④ Positive feedback loop continues accelerating │
│ → More compute → smarter models → better chips │
└─────────────────────────────────────────────────────────┘
7. The Compute Arms Race: OpenAI vs Anthropic
7.1 Strategic Implications of the Compute Gap
According to the leaker, OpenAI’s internal assessment indicates that Anthropic, due to compute shortages, will struggle to produce a competitive response to Astra for most of the remaining 2026. While Anthropic expects to regain the lead by early 2027, this “window” could determine market structure.
Compute Comparison: OpenAI vs Anthropic (August 2026)
Compute Scale (Relative)
OpenAI
┌──────────────────────────────────────────────────────────────┐
│ ██████████████████████████████████████████████████████████ │
│ • Stargate: 10GW by 2029 target already exceeded │
│ • Jalapeño chip: deploy end-2026, scale in 2027 │
│ • Gigawatt-scale data centers with MS, Oracle, SoftBank │
│ • Multi-model parallel training capability │
└──────────────────────────────────────────────────────────────┘
Anthropic
┌──────────────────────────────────────────────────────┐
│ ████████████████████████████████████████████████ │
│ • 220K+ NVIDIA GPUs planned (mostly late 2026-2027) │
│ • Amazon: up to 5GW compute │
│ • Google & Broadcom: 5GW combined │
│ • Short-term bottleneck, expected relief by 2027 │
└──────────────────────────────────────────────────────┘
Timeline: 2026 Q3 ── 2026 Q4 ── 2027 Q1 ── 2027 Q2
OpenAI Edge:████████████████████░░░░░░░░░░░░░░░░░░
Anthropic :░░░░░░░░░░░░░░████████████████████████
Sources: Zeniteq, CryptoBriefing, Wccftech
7.2 The Moat of Custom Silicon
Jalapeño’s significance goes beyond raw performance — it’s about strategic independence. OpenAI still relies on NVIDIA GPUs for training, but for inference, it has achieved “de-NVIDIA-fication”:
// Inference Chip Scheduling Strategy (Go implementation)
package main
import "fmt"
type ChipType int
const (
NVIDIA_GB300 ChipType = iota
NVIDIA_GB200
OPENAI_JALAPENO
CEREBRAS
)
type InferenceRequest struct {
Model string
LatencyMs int
Priority int
Tokens int
}
type ChipScheduler struct {
jalapenoAvailable bool
cerebrasAvailable bool
nvidiaAvailable bool
}
func (s *ChipScheduler) SelectChip(req InferenceRequest) string {
switch {
case req.Priority >= 4 && s.jalapenoAvailable:
return "Jalapeño" // Lowest latency for priority tasks
case req.Tokens > 10000 && s.nvidiaAvailable:
return "NVIDIA GB300" // Training ecosystem
case req.LatencyMs < 100 && s.cerebrasAvailable:
return "Cerebras (Ultra Fast)" // 14x speed
default:
if s.jalapenoAvailable {
return "Jalapeño" // Best cost-performance
}
return "NVIDIA GB200"
}
}
func main() {
scheduler := ChipScheduler{
jalapenoAvailable: true,
cerebrasAvailable: true,
nvidiaAvailable: true,
}
requests := []InferenceRequest{
{Model: "GPT-5.6 Sol", LatencyMs: 50, Priority: 5, Tokens: 500},
{Model: "Codex-Pro", LatencyMs: 200, Priority: 3, Tokens: 5000},
{Model: "Luna-Batch", LatencyMs: 1000, Priority: 1, Tokens: 50000},
{Model: "Ultra-Fast", LatencyMs: 10, Priority: 5, Tokens: 100},
}
fmt.Println("Inference Chip Scheduling (Multi-Chip Strategy)")
fmt.Println("=" * 50)
for _, req := range requests {
chip := scheduler.SelectChip(req)
fmt.Printf("[%s] Priority=%d, Latency=%dms → %s\n",
req.Model, req.Priority, req.LatencyMs, chip)
}
}
Output:
Inference Chip Scheduling (Multi-Chip Strategy)
==================================================
[GPT-5.6 Sol] Priority=5, Latency=50ms → Jalapeño
[Codex-Pro] Priority=3, Latency=200ms → Jalapeño
[Luna-Batch] Priority=1, Latency=1000ms → NVIDIA GB300
[Ultra-Fast] Priority=5, Latency=10ms → Cerebras (Ultra Fast)
7.3 Beyond Compute Determinism
Of course, compute isn’t everything. Anthropic’s depth in alignment safety, Google DeepMind’s Gemini 4 (1.5M token context window, terminal integration), and the rapid catch-up of China’s DeepSeek and GLM all contribute to a complex competitive landscape. But it’s undeniable that in the AGI race, compute has become the hardest constraint.
8. The Personal AGI Endgame: Tibo’s Ultra Fast and Dynamic UI Adaptation
8.1 ChatGPT and Codex Convergence
Tibo made it clear in the interview (Source: 36Kr): ChatGPT and Codex are merging, with the goal of creating a “Personal AGI” — a universal agent that deeply understands user goals.
Personal AGI Architecture Evolution
Current (August 2026)
┌──────────┐ ┌──────────┐ ┌──────────┐
│ ChatGPT │ │ Codex │ │ API │
│ General │ │ Coding │ │ Developer│
│ Chat │ │ Agent │ │ Interface│
└──────────┘ └──────────┘ └──────────┘
Future (Personal AGI)
┌──────────────────────────────────────────────────────┐
│ Personal AGI (Unified Agent) │
├──────────────────────────────────────────────────────┤
│ ┌────────────────────────────────────────────────┐ │
│ │ Adaptive UI Layer │ │
│ │ │ │
│ │ Programmer → Code Editor + Terminal + Debugger│ │
│ │ Designer → Canvas + Preview + Asset Library │ │
│ │ Manager → Dashboard + Reports + Meeting Notes │ │
│ │ Consumer → Chat + Voice + Shared Canvas │ │
│ │ │ │
│ │ "Not users choosing tools, but tools adapting │ │
│ │ to users" │ │
│ └────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────▼────────────────────────┐ │
│ │ Passive Understanding Engine │ │
│ │ │ │
│ │ • Observes user behavior → learns workflow │ │
│ │ • Understands coding context → predicts needs │ │
│ │ • Proactive suggestions (not annoying popups) │ │
│ │ • Present everywhere → visible only when needed│ │
│ └────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────▼────────────────────────┐ │
│ │ Cloud Agent Runtime │ │
│ │ │ │
│ │ • Not limited by laptop (100+ apps simult.) │ │
│ │ • Ultra Fast mode (14x speed → real-time) │ │
│ │ • Parallel: explore + test + compile + verify │ │
│ │ • Industry default within 2 years (Tibo) │ │
│ └────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────┘
8.2 Ultra Fast Mode: What 14x Speed Means
Tibo revealed that Ultra Fast mode has achieved 14x speedup (Source: 36Kr). This means:
- Solo developer workflow revolution: From running 10-15 agents waiting 30-40 minutes, to just 3-4 agents with real-time interaction
- Bottleneck shift: From “model generation too slow” to “network and tool calls are the bottleneck”
- Creative workflow: AI can prototype in one minute, users iterate — “choose your own adventure” interaction
8.3 Dynamic UI Adaptation
Tibo described the Personal AGI interaction paradigm:
“What people really want is an assistant that deeply understands them. It understands your goals, your daily schedule, what your team is doing. It not only responds to requests but should proactively act when appropriate, helping with daily tasks while always feeling like your perfect partner.”
This aligns with Sam Altman’s August 24 interview (Source: The Paper):
“We have all the technical components now, but we haven’t yet had that iPhone moment that fundamentally changes how humans interact with technology.”
In other words, AI’s technical capabilities are ready, but the interaction paradigm is still waiting for its “multi-touch” breakthrough. Personal AGI is the candidate for this breakthrough.
9. Astra’s Impending Release: New Evidence
On August 29, testingcatalog reported that OpenAI is expanding Astra’s internal testing, adding a “mozaik-alpha-fdm” test phase (Source: IT之家 reprint).
Shared test examples show Astra, in zero-shot Max inference mode, successfully creating a GTA 2-like game, detailed websites, 3D objects, and voxel environments in a single conversation. Although inference time is significantly longer than GPT-5.6 Sol, output quality is stunning.
Astra Release Timeline (As of Now)
2026-08-01 OpenAI publishes Astra research: 10 math breakthroughs
2026-08-07 OpenAI: Astra may reach "critical cyber capability" threshold
2026-08-18 OpenAI pauses some frontier RL training, strengthens monitoring
2026-08-25 Bel pretraining leak (@synthwavedd)
2026-08-26 TIME Altman interview: internal AGI by year-end
2026-08-29 "mozaik-alpha-fdm" test phase exposed
2026-09-03 ★ Expected Astra expanded testing ("next Thursday")
??? Astra official release (speculated as GPT-6 or GPT-5.7)
Sources: testingcatalog, TIME, OpenAI blog, 36Kr, IT之家
10. Conclusion: When Will AGI Arrive?
10.1 Three Time Horizons
Based on available information, we can project AGI’s arrival across three time horizons:
AGI Timeline Forecast (Based on Public Information)
End of 2026 ──────────────────────────────────────────────────▶
✅ Sam Altman: Internal system he'd call AGI
✅ Mark Chen: "80% of the way there"
✅ Bel pretraining complete, Astra imminent
⚠️ Note: "Internal system," not public release
2027-2028 ────────────────────────────────────────────────────▶
✅ Anthropic expects to retake lead by early 2027
✅ OpenAI expects Bel model family to mature
✅ Jalapeño chip大规模 deployment, compute costs plummet
⚠️ Consensus: Super-capable AI agents likely
⚠️ But not necessarily AGI in the strict sense
2028+ ────────────────────────────────────────────────────────▶
❌ Altman's more conservative prediction
❌ Yann LeCun: Pure Transformer can't reach true AGI
❌ Core gaps: no world model, compositional generalization, alignment
⚠️ Most contested: whether architecture needs fundamental overhaul
10.2 A Rational Perspective
Bel’s emergence is undoubtedly a landmark moment in AI history. But we must maintain perspective:
- The 10 trillion parameter figure is unconfirmed by OpenAI — currently based on a single X user’s leak (Source: traictory.com)
- Total params ≠ active params — under MoE, actual inference cost may be far lower than the headline number suggests
- From pretraining to product is a long road — RLHF, safety evaluation, alignment, and productization take months
- The definition of AGI itself is fluid — OpenAI’s definition (“highly autonomous systems that surpass human performance on most economically valuable work”) differs significantly from other institutions'
But regardless, the week of August 25, 2026, showed us the most exciting technical breakthroughs in AI. From Bel’s 10 trillion parameter pretraining, to dual-speed learning, to the RSI business flywheel, to the AI-self-designed Jalapeño chip — every development tells us: AGI is no longer a philosophical question, but an engineering problem.
References:
- 新智元/Toutiao — OpenAI神秘Bel泄露、超10万亿参数 (2026-08-26)
- 36Kr — Codex负责人Tibo访谈：递归式自我改进从基础设施优化开始 (2026-08-26)
- TIME — Inside OpenAI’s Reboot (2026-08-26)
- IT之家 — 预估为GPT-6模型：OpenAI推进Astra测试 (2026-08-30)
- Sina Finance — OpenAI自研芯片Jalapeño性能实测 (2026-08-27)
- Sina Finance — OpenAI能否实现AGI？最新进展与行业共识 (2026-08-26)
- The Paper — 奥特曼最新采访：AI还没有到iPhone时刻 (2026-08-31)
- EETimes — First Benchmarks for Jalapeño (2026-08-27)
- TestingCatalog — First outputs from GPT-6 Astra (2026-08-29)
- OpenAI Official Blog — Ten advances in mathematics (2026-08-01)
- OpenAI Official Blog — Pacing model development (2026-08-18)
- traictory.com — Did OpenAI Really Finish a 10-Trillion Run? (2026-08-27)
- Zeniteq — OpenAI Reportedly Finished Training Bel (2026-08-26)
- llm-stats.com — RSI Index Leaderboard (2026-08-30)
- TechRepublic — OpenAI’s Jalapeño Benchmark (2026-08-27)