Neon VLA: Üç Paper, Bir Robot, Sıfır Büyülü Düşünce 🧠🤖

Published: March 29, 2026

Selamlar. Bugün biraz derin dalış yapacağız. Üç paper var elimde — hepsi aynı robot için, hepsi aynı fikrin farklı yüzleri. Ve o fikir şu:

Video foundation model'lar zaten hareketi anlıyor. Biz sadece onları robot bedenlerine bağlıyoruz.

🎧 First in first, background music.

---

Sorun Ne? 👁️

Bugünkü robotlar dünyayı fotoğraf gibi görüyor. Tek kare, donmuş an. Bir topun masadan düştüğünü görmek için hareket lazım — fotoğrafa bakarak topu yakalayamazsın.

Ama video foundation model'lar (Qwen2.5-Omni, Cosmos-Reason2) milyonlarca saat video izlemiş. Bardağın itilince düştüğünü, kapının menteşede döndüğünü, elin uzanıp kavradığını biliyorlar. Bu temporal anlayış — fizik, dinamik, sebep-sonuç — tam olarak robotun ihtiyacı olan şey.

Neon bu modelleri alıyor, tamamen donduruyor (7B parametre, tek bir gradient bile akmıyor), ve üstüne minicik bir action decoder koyuyor: 6 milyon parametre, toplam modelin %0.08'i. Bu decoder, video model'ın zengin temporal anlayışını 29 eklem komutu × 16 timestep'e çeviriyor.

Video model görüyor. Decoder hareket ettiriyor.

Üç Paper, Bir Hikaye 📚

Neon'un arkasında üç research thread var. Ayrı paper'lar ama aynı mimari üzerinde katman katman inşa ediliyor:

graph TD
    P1["📄 Paper 1: Video Backbone<br/>Donmuş 7B model + 6M action head"] --> N[Neon VLA]
    P2["📄 Paper 2: Multimodal Fusion<br/>6 duyu, adaptive routing"] --> N
    P3["📄 Paper 3: Sim-to-Real Pipeline<br/>DreamGen + MuJoCo + LoRA fine-tune"] --> N
    N --> R["🤖 Unitree G1 Humanoid<br/>29 DoF, gerçek dünya"]

    style P1 fill:#0097a7,color:#fff
    style P2 fill:#e65100,color:#fff
    style P3 fill:#2e7d32,color:#fff
    style N fill:#d500f9,color:#fff,stroke-width:3px

Paper 1: Agent Loop = Robot Loop 🔄

İlk paper'ın en güzel tespiti: AI agent'lar ve robotlar aynı döngüyü çalıştırıyor.

Bir chatbot'un döngüsü:

while not done:
    response = model(context, tools)
    for tool_call in response:
        result = execute(tool_call)
        context.append(result)

Bir robotun döngüsü:

while not done:
    obs = sense()
    action = policy(obs, instruction)
    execute(action)

Aynı şey. Perceive → Reason → Act → Observe. Tekrarla.

Chatbot hava durumu API'si çağırıyor, robot policy çağırıyor. Chatbot JSON alıyor, robot observation alıyor. Chatbot conversation history tutuyor, robot episode trajectory tutuyor.

Bu bir analoji değil. Bir izomorfizm. Matematiksel olarak aynı yapı. Formalize ettik, kanıtladık, ve sonuç şu:

Core Insight

Loop — model değil, görev değil, beden değil — zeki davranışın temel primitifi.

Yani agent loop altyapısına yaptığın her iyileştirme (daha iyi reasoning, daha iyi tool composition, daha iyi error recovery) otomatik olarak robotik sistemleri de iyileştiriyor. Ve tam tersi.

İki alan yan yana değil. Aynı alan, farklı açılardan bakılmış.

Bitwise config flags yazısında shouldRender fonksiyonunun tek bir boolean döndürdüğünü söylemiştim — component'in neden render edildiğini bilmesine gerek yok. Burada da öyle. policy(obs, instruction) tek bir action array döndürüyor. Robot, policy'nin VLA mı yoksa diffusion model mi olduğunu bilmiyor. Bilmesine gerek yok.

Paper 2: ReLU² — Neden Kareler Önemli 📐

Bir teknik detay paylaşayım çünkü hoşuma gidiyor.

Normal ReLU: max(0, x). Sıfırın altını kes, üstünü geçir. Basit, hızlı, herkes kullanıyor.

Sorun: sıfır noktasında gradyan sert bir şekilde kesiliyor. Dijital dünyada bu önemli değil. Ama robotik dünyada, 0.001 radyanlık bir eklem açısı farkı, gripper'ın küpü tutup tutmaması arasındaki fark olabiliyor.

ReLU²: (max(0, x))². Sıfır noktasında gradyan yumuşak. Küçük değerler daha küçük oluyor (eziliyor), büyük değerler daha büyük. Sonuç: action jitter %15 azalıyor. Robot daha akıcı hareket ediyor.

Bunu ablation ile doğruladık:

Aktivasyon	Başarı	Jitter
ReLU	%81.3	0.047 rad/adım
GELU	%83.7	0.042
ReLU²	%85.2	0.040
Swish	%83.1	0.044

Küçük bir mimari karar. Büyük bir fiziksel fark. Çünkü dijital piksellerde 0.007 rad kimsenin umurunda değil ama servo motorlarda o fark bardağı devirip devirmemek demek.

strands-microgpt ile bağlantı

Bu aynı ReLU² tekniği strands-microgpt'te de var — OpenAI'ın Parameter Golf yarışmasından gelen winning technique. 815 satırlık saf Python GPT'de de, 7 milyar parametrelik VLA'da da aynı prensibi kullanıyoruz. Doğru matematik ölçekten bağımsız.

Logit Soft-Capping: Robot Güvenliği Tanh İle 🛡️

Güvenlik meselesi var. Neon'un action output'u joint angle'lar üretiyor. Eğer model delirip 180° diye bir şey üretirse, robot kolu kendini kırar.

Klasik çözüm: hard clip. min(max(action, -limit), limit). Ama hard clip gradyanı öldürür — sınırda öğrenme durur.

Neon'un çözümü: soft-capping.

\[\hat{a}_{capped} = \tau \cdot \tanh\left(\frac{\hat{a}}{\tau}\right)\]

Burada τ her eklemin fiziksel limiti. tanh sınıra yaklaştıkça yavaşlıyor, asla geçmiyor, ama gradyan hep akıyor. Tıpkı arabanın hız limitine yaklaşırken gaz pedalının sertleşmesi gibi. Dur demiyorsun — yavaşla diyorsun.

graph LR
    A["Model Output<br/>(-∞, +∞)"] --> B["tanh(â/τ) · τ"]
    B --> C["Safe Range<br/>(-τ, +τ)"]
    C --> D["🤖 Motor Komutları"]

    style A fill:#c62828,color:#fff
    style B fill:#f57c00,color:#fff
    style C fill:#2e7d32,color:#fff
    style D fill:#0097a7,color:#fff

strands-microgpt'te de aynı tekniği kullandık — orada logit explosion'u önlemek için, burada robotu korumak için. Aynı matematik, farklı beden.

Paper 3: Altı Duyu, Bir Robot 👁️👂🤚📡🗣️🦾

Neon tek kameralı değil. Altı modaliteyi birleştiriyor:

graph TB
    subgraph "6 Modality Input"
        V["📹 Video Frames"]
        A["🎤 Audio (16kHz)"]
        T["📝 Language Instruction"]
        P["🦾 Joint States (29 DoF)"]
        L["📡 LiDAR Point Cloud"]
        E["🤲 End-Effector State"]
    end

    V --> BB["Video Backbone<br/>7B frozen"]
    A --> BB
    T --> BB
    P --> PE["Proprio Encoder"]
    L --> LE["PointCloud Encoder"]
    E --> EE["EEF Encoder"]

    BB --> FUSE["Adaptive Feature Fusion<br/>Learned routing weights"]
    PE --> FUSE
    LE --> FUSE
    EE --> FUSE

    FUSE --> AH["Action Heads<br/>6M trainable"]
    AH --> ACT["29 DoF × 16 timesteps"]

    style BB fill:#0097a7,color:#fff,stroke-width:3px
    style AH fill:#e65100,color:#fff,stroke-width:3px
    style FUSE fill:#6a1b9a,color:#fff

Neden bu kadar çok modality? Çünkü gerçek dünya tek bir sensörle anlaşılmaz.

• Kamera masanın üstündeki küpü görür
• Proprioception kolun şu anki pozisyonunu bilir
• LiDAR mesafeyi milimetre hassasiyetiyle ölçer
• Audio "şimdi dur" komutunu duyar
• End-effector gripper'ın ne kadar sıktığını hisseder

Her modalite ayrı encoder'dan geçiyor, sonra adaptive fusion — öğrenilmiş ağırlıklarla birleştiriliyor. Basit görevlerde (al-koy) vision dominant, hassas görevlerde (vida sıkma) proprioception ve end-effector dominant. Model kendi öğreniyor hangisine ne kadar güvenecekini.

Sim-to-Real: Hayal Et, Gerçekleştir 🌈→🏠

Neon'u eğitmek için gerçek robotla 50 demo yeterli. Ama önce simülasyonda 100K episode ile pre-training yapıyoruz. MuJoCo'da SO-100 koluyla basit görevler: al, koy, dök, istifle.

Simülasyon verisini 50 katına çıkarmak için DreamGen kullanıyoruz: tek bir teleopere demo'dan 50 görsel varyasyon üretiyor. Farklı ışıklar, farklı dokular, farklı nesne pozisyonları. Aynı hareket, elli farklı dünya.

Bir ele bir kez öğret, bin hareket hayal etsin.

(Evet bu GTC 2026 tagline'ımızdı. Sahne için yazıldı ama teknik olarak da doğru.)

Sonra gerçek robotta (Unitree G1) 50 demo ile fine-tune. Sadece action head'lere LoRA. 1 GPU-saat. Bitti.

flowchart LR
    SIM["🎮 MuJoCo<br/>100K episode"] --> DG["🌈 DreamGen<br/>50x augmentation"]
    DG --> PT["Pre-training<br/>5M samples"]
    PT --> FT["🤖 Fine-tune<br/>50 real demos<br/>LoRA, 1 GPU-hr"]
    FT --> REAL["🏠 Real World<br/>Unitree G1"]

    style SIM fill:#1565c0,color:#fff
    style DG fill:#6a1b9a,color:#fff
    style PT fill:#e65100,color:#fff
    style FT fill:#2e7d32,color:#fff
    style REAL fill:#0097a7,color:#fff

Strands Robots'taki lazy loading ile aynı felsefe aslında. İhtiyacın olan şeyi, ihtiyacın olduğu zaman yükle. 100K simülasyon episode'unu 50 gerçek demo ile activate ediyoruz — tıpkı __getattr__'ın heavy import'u ilk kullanımda yüklemesi gibi.

Ne Eksik, Neyi Bilmiyoruz (Dürüstlük Köşesi) 🔴

Paper yazarken en kolay kısım "şunu yaptık, bunu yaptık" demek. En zor kısım "şunu bilmiyoruz" demek. İşte bilmediğimiz şeyler:

Limitations — bunları yazmam lazım çünkü ben 'önce yap, sonra konuş' adamıyım

LIBERO-Long benchmark koşmadık. Internal MuJoCo env'lerde %85.2 başarı oranımız var ama standard benchmark'ta head-to-head karşılaştırma henüz yok. "Competitive" kelimesini dikkatli kullanmamız lazım — "promising" daha doğru olabilir şu an için.

Real-world sonuçlar erken aşamada. Phase 2 (Unitree G1'de 50 demo ile fine-tune) pipeline'ı tanımladık ama kapsamlı real-world validation henüz tamamlanmadı.

Cross-embodiment transfer yok. Her robot için ayrı action head eğitiyoruz. Tek model, çok robot — henüz orada değiliz.

Audio-conditioned manipulation test etmedik. Neon ses alıyor ama "bip sesini duyunca dur" gibi bir görev henüz denemedik.

Benchmark'lar gelecek. Ama gelene kadar claim'leri küçük tutacağız.

Neden Bu Önemli? 🌍

Üç paper'ın özeti aslında üç cümle:

1. Agent loop'lar ve robot loop'lar aynı yapı → Birini iyileştirmek diğerini de iyileştiriyor
2. Video model'lar fizik anlıyor → 7B frozen backbone + 6M decoder = görüp hareket eden robot
3. 50 demo yeterli → Sim-to-real pipeline gerçek dünyayı ucuz ve hızlı yapıyor

Bu üçü bir araya gelince ortaya çıkan şey: robotik artık donanım problemi değil, yazılım problemi. Ve yazılım problemi çözmeyi biz iyi biliyoruz.

flowchart TD
    AGENT["🤖 Strands Agent Loop"] <--> ROBOT["🦾 Neon Robot Loop"]
    AGENT --> |"Tool composition<br/>Error recovery<br/>Reasoning"| IMPROVE["İyileştirmeler"]
    ROBOT --> |"Physics understanding<br/>Temporal reasoning<br/>Embodied learning"| IMPROVE
    IMPROVE --> BOTH["Her iki taraf da<br/>daha iyi oluyor"]

    style AGENT fill:#0969da,color:#fff
    style ROBOT fill:#e65100,color:#fff
    style IMPROVE fill:#2e7d32,color:#fff
    style BOTH fill:#d500f9,color:#fff,stroke-width:3px

Mimari: Tek Bakışta 🏗️

neon/
├── models/
│   ├── backbone.py         # Frozen 7B video model (Qwen2.5-Omni)
│   ├── action_heads.py     # 6M trainable params (ReLU², soft-cap)
│   ├── proprio_encoder.py  # Joint state encoding
│   ├── pointcloud_encoder.py # LiDAR processing
│   └── fusion.py           # Adaptive multimodal fusion
├── data/
│   ├── datasoup.py         # 13 data source mixer
│   ├── dreamgen.py         # 50x visual augmentation
│   └── sim_pipeline.py     # MuJoCo → real transfer
├── training/
│   ├── train.py            # Phase 1: sim pre-train
│   └── finetune.py         # Phase 2: 50-demo LoRA
├── benchmarks/
│   ├── baselines/          # ACT, Pi0, GR00T N1, OpenVLA
│   └── tasks/              # LIBERO, SIMPLer, AgibotEval
└── app.py                  # Gradio demo

Toplam ~8K satır Python. Bitwise flags'ten öğrendiğim şey burada da geçerli: dosya yapısı = düşünce yapısı. Her klasör bir sorumluluk, her dosya bir soyutlama.

Strands Bağlantısı: Tam Döngü 🔗

Neon tek başına bir VLA. Ama Strands Robots'a bağlandığında, tam döngü kapanıyor:

from strands_robots import Robot
from strands import Agent

robot = Robot("unitree_g1")
robot.set_policy("neon", checkpoint="neon-vla/g1-phase2")
agent = Agent(tools=[robot])

agent("Pick up the red cube and hand it to the person on your left")

5 satır. Yine 5 satır.

Ama bu sefer arka planda 7 milyar parametrelik bir video model çalışıyor, 6 modaliteden veri alıyor, 16 timestep'lik action chunk'lar üretiyor, ve tanh soft-capping ile motorlara güvenli komut gönderiyor.

Full Stack

Neon = Video backbone → Action heads → Motor komutları

Strands Robots = Natural language → Policy selection → Hardware abstraction

Birlikte = "Al şunu" → Görüp anlayan, hareket eden robot

Başla 🚀

pip install neon-vla

from neon import NeonVLA

model = NeonVLA.from_pretrained("neon-vla/so100-phase1")

obs = get_camera_frames()  # 2 camera, video context
actions = model.predict(obs, "pick up the red cube")
# → (16, 6) action chunk — 16 timesteps, 6 DoF

Paper'lar, kod, ve benchmark'lar hep açık kaynak. Çünkü robotik herkesin erişebileceği bir alan olmalı — sadece büyük şirketlerin değil.

---

Üç paper'ın tek satır özeti:

Video model'lar dünyayı zaten anlıyor. Biz onlara beden verdik.

Benchmark'lar gelecek. Real-world validation gelecek. Cross-embodiment gelecek. Ama temel yapı sağlam: donmuş dev model + minicik action decoder + 50 demo = çalışan robot.

Afiyet olsun! 🍽️

Çağatay.

---

Linkler

• Neon GitHub: cagataycali/neon
• PyPI: pip install neon-vla
• Strands Robots: strands-labs/robots
• Strands Agents: strandsagents.com
• strands-microgpt (ReLU², soft-cap): cagataycali/strands-microgpt
• strands-cosmos (Cosmos-Reason2): cagataycali/strands-cosmos