Tencent Tairos Embodied AI Three Models Open Source: 30B VLM + 62B World Model + VLA Full Stack Deep Dive

Tencent Tairos Embodied AI Three Models Open Source: 30B VLM + 62B World Model + VLA Full Stack Deep Dive

1. Introduction: The “Android Moment” for Embodied AI

At WAIC 2026, Tencent’s Robotics X and Hunyuan teams, under the Tairos platform, open-sourced three embodied AI models simultaneously: Hy-Embodied-VLM-1.0 (30B MoE vision-language model), Hy-Embodied-RxBrain-1.0 (62B world model), and Hy-Embodied-VLA-0.5 (vision-language-action model), corresponding to the three stages of “see, imagine, act.”

This is the first time a single team has simultaneously open-sourced the perception, planning, and execution layers of embodied AI within the same technical framework. If hardware companies build different forms of “phones,” Tencent aims to provide a cross-device “universal intelligence software stack” — potentially the “Android moment” for embodied AI.

2. Three-Model Architecture Overview

2.1 Decoupled Engineering Philosophy

VLM (30B) → "See" — visual language perception
RxBrain (62B) → "Imagine" — world model for planning
VLA (0.5B) → "Act" — action execution

2.2 Why Three-Layer Separation?

A language model can tell you “the cup is on the table.” But a robot facing the real world needs to answer:

  • How far is the cup from the table edge?
  • Which direction is the handle facing?
  • Will the arm collide with the bowl next to it?
  • Will water spill when grasped?

This is the watershed between embodied AI and chatbots — the former’s reasoning lands in the physical world, facing gravity, friction, occlusion, collision, delay, and failure.

3. Hy-Embodied-VLM-1.0: The 30B “Right Brain”

3.1 Architecture

A 30B parameter MoE VLM, activating only ~3B parameters per token.

type MoETransformerLayer struct {
    Attention    *MultiHeadAttention
    AttnNorm     *LayerNorm
    Router       *MoERouter
    Experts      []*FeedForward
    SharedExpert *FeedForward
    OutputNorm   *LayerNorm
}

type MoERouter struct {
    Weights    [][]float32
    TopK       int
    NoiseScale float32
}

func (r *MoERouter) Route(hidden [][]float32) ([][]int, [][]float32) {
    batchSize := len(hidden)
    seqLen := len(hidden[0])
    
    expertIndices := make([][]int, batchSize)
    expertWeights := make([][]float32, batchSize)
    
    for b := 0; b < batchSize; b++ {
        for s := 0; s < seqLen; s++ {
            logits := matVecMul(hidden[b][s], r.Weights)
            // Select Top-K experts
            type es struct { idx int; score float32 }
            ranked := make([]es, len(logits))
            for i, s := range logits {
                ranked[i] = es{idx: i, score: s}
            }
            sort.Slice(ranked, func(i, j int) bool {
                return ranked[i].score > ranked[j].score
            })
            
            indices := make([]int, r.TopK)
            weights := make([]float32, r.TopK)
            for i := 0; i < r.TopK; i++ {
                indices[i] = ranked[i].idx
                weights[i] = ranked[i].score
            }
            // Normalize weights
            sum := 0.0
            for _, w := range weights {
                sum += float64(w)
            }
            for i := range weights {
                weights[i] = float32(float64(weights[i]) / sum)
            }
            expertIndices[b] = append(expertIndices[b], indices...)
            expertWeights[b] = append(expertWeights[b], weights...)
        }
    }
    return expertIndices, expertWeights
}

3.2 Embodied VLM vs Generic VLM

Generic VLM: “There is a cup in the image.” Embodied VLM must also answer:

  1. Object state (static/moving/tipped/liquid amount)
  2. Action consequences (what changes after acting?)
  3. Long-horizon task adjustment
class EmbodiedVLMLoss(nn.Module):
    def __init__(self, alpha_desc=1.0, alpha_action=0.5, alpha_physics=0.3):
        super().__init__()
        self.alpha_desc = alpha_desc
        self.alpha_action = alpha_action
        self.alpha_physics = alpha_physics
        
    def forward(self, logits, targets, action_preds, action_targets, 
                physics_preds, physics_targets):
        desc_loss = F.cross_entropy(logits.reshape(-1, logits.size(-1)),
                                    targets.reshape(-1))
        action_loss = F.mse_loss(action_preds, action_targets)
        physics_loss = F.mse_loss(physics_preds, physics_targets)
        
        return (self.alpha_desc * desc_loss + 
                self.alpha_action * action_loss + 
                self.alpha_physics * physics_loss), {
            "desc_loss": desc_loss.item(),
            "action_loss": action_loss.item(),
            "physics_loss": physics_loss.item(),
        }

4. Hy-Embodied-RxBrain-1.0: The 62B “Dreaming Brain”

4.1 Core Innovation

RxBrain generates interleaved text steps and visual target images within the same reasoning sequence — it “imagines the future” before acting.

class RxBrainWorldModel(nn.Module):
    def __init__(self, text_vocab_size=128000, image_vocab_size=16384,
                 hidden_dim=8192, num_layers=64):
        super().__init__()
        self.text_embed = nn.Embedding(text_vocab_size, hidden_dim)
        self.image_embed = nn.Embedding(image_vocab_size, hidden_dim)
        self.type_embed = nn.Embedding(2, hidden_dim)
        self.layers = nn.ModuleList([
            MoTTransformerLayer(hidden_dim, 64) for _ in range(num_layers)
        ])
        self.text_head = nn.Linear(hidden_dim, text_vocab_size)
        self.image_head = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim * 2),
            nn.GELU(),
            nn.Linear(hidden_dim * 2, image_vocab_size),
        )
    
    def plan_sequence(self, initial_prompt, num_steps=5):
        """Generate interleaved text steps and visual goals"""
        sequence = [initial_prompt]
        for step in range(num_steps):
            tokens = self._tokenize(sequence[-1])
            outputs = self.generate(tokens, max_new_tokens=256)
            text_step, image_tokens = self._parse_output(outputs)
            sequence.append({
                "step": step + 1,
                "text": text_step,
                "image": self._decode_image(image_tokens),
            })
        return sequence

4.2 Benchmark Results

TaskSuccess Rate
Table setting97%
Glasses folding/storage95%
Trash pickup68%
Average87%

5. Hy-Embodied-VLA-0.5: 10,000 Hours of Data-Driven Action

5.1 From “I Know” to “I Can Do”

VLA-0.5 receives language instructions and visual input, outputs continuous robot arm trajectories and end-effector poses. Behind it is 10,000+ hours of first-person UMI operation data.

type ActionDecoder struct {
    ActionDim int  // 6D pose + 1D gripper + 3D force
    Horizon   int  // prediction horizon
    NumModes  int  // GMM modes
}

func (d *ActionDecoder) DecodeAction(fusedFeatures [][]float32,
                                       robotState []float32) [][]float32 {
    combined := append(fusedFeatures[0], robotState...)
    h := denseLayer(combined, d.HiddenDim, FnReLU)
    h = denseLayer(h, d.HiddenDim, FnReLU)
    output := denseLayer(h, d.NumModes*(d.ActionDim*d.Horizon*2+1), FnLinear)
    
    // Parse GMM parameters and select best mode
    bestMode := 0
    bestWeight := float32(-1e9)
    for m := 0; m < d.NumModes; m++ {
        weight := softmax(output[d.ActionDim*d.Horizon*2:])[m]
        if weight > bestWeight {
            bestWeight = weight
            bestMode = m
        }
    }
    
    offset := bestMode * (d.ActionDim*d.Horizon*2 + 1)
    actions := make([][]float32, d.Horizon)
    for t := 0; t < d.Horizon; t++ {
        actions[t] = output[offset+t*d.ActionDim : offset+(t+1)*d.ActionDim]
    }
    return actions
}

5.2 Production Line Results

MetricValue
Per-unit processing time~6 seconds
Accuracy>95%
New SKU training cycleDays (vs weeks)
Supported robot typesYuejiang, Jaka, Unitree, Xingchen, Zhiyuan, etc.

6. Tairos Platform: Connecting Perception-Planning-Action

class TairosPipeline:
    def __init__(self, model_dir, robot_type):
        self.vlm = load_vlm(f"{model_dir}/vlm-1.0")
        self.rxbrain = load_rxbrain(f"{model_dir}/rxbrain-1.0")
        self.vla = load_vla(f"{model_dir}/vla-0.5")
    
    def execute_task(self, instruction, observation):
        # Step 1: VLM perceives scene
        scene = self.vlm.describe_scene(observation)
        # Step 2: RxBrain plans
        plan = self.rxbrain.plan_sequence(f"{instruction}. Scene: {scene}")
        # Step 3: VLA executes step by step
        actions = []
        for step in plan:
            action = self.vla.execute_step(step["text"], observation)
            actions.append(action)
        return actions
    
    def fine_tune_for_new_robot(self, new_robot_type, demo_data):
        # Freeze all except RobotAdapter
        for param in self.vla.parameters():
            param.requires_grad = False
        for param in self.vla.robot_adapter.parameters():
            param.requires_grad = True
        # Quick fine-tuning
        optimizer = torch.optim.AdamW(
            self.vla.robot_adapter.parameters(), lr=1e-5
        )
        for epoch in range(100):
            loss = compute_demo_loss(demo_data)
            loss.backward()
            optimizer.step()

7. Conclusion

Tencent’s Tairos platform represents the most systematic and complete open-source release of embodied AI foundation models to date. The 30B MoE VLM for efficient perception, the 62B RxBrain “visual storyboard” world model, and the data-driven VLA-0.5 for action execution form a complete closed-loop from “see” to “imagine” to “act.”

Whether the “Android moment” for embodied AI has truly arrived remains to be validated by time and industry adoption. But one thing is certain: Tencent has laid the most critical infrastructure for this transformation.