A 9B Model Beats GPT-6 Astra? The Embodied Space Revolution of DaXiao ACE-Brain-0.6: How a Million Spatial-Anchor Samples Unlock Log-Linear Progress

A 9B Model Beats GPT-6 Astra? The Embodied Space Revolution of DaXiao ACE-Brain-0.6

Introduction: A 9B Model Challenges the Top Multimodal Model

If you follow robotics, you’ve surely heard the recurring puzzle: general large models “know everything,” but when put on a real robot they get confused—with “put the fruit in the basket,” they recognize the fruit and the basket, yet still can’t quite figure out where the basket rim is, which part to grab, or which direction to move.

On October 19, DaXiao Robotics released ACE-Brain-0.6, a vision spatial-anchoring-enhanced embodied foundation model that tackles this pain point head-on. It has only 9B parameters, yet across a battery of “Grounding” evaluations, it beat OpenAI’s GPT-6 Astra on six out of eight; it scored 74.53 average on seven international public benchmarks, edging past Astra’s 73.68; and on DaXiao’s own real-robot-scenario benchmark RobotGrounding, it hit 94.13, leading Astra by about 3.03 points.

What’s truly worth chewing on isn’t “another leaderboard champion” but the technical judgment hidden in that one sentence: in the spatial-perception link that directly determines physical-operation precision, a 9B-grade small model, trained on roughly a million “high-quality, verifiable” spatial-anchor samples, can form a specialist capability on par with—or better than—a top general model. That draws a new tick mark on the question “how far can embodied intelligence go with a small model plus good data.”

DaXiao itself is also noteworthy: founded by Wang Xiaogang, co-founder of SenseTime, it had completed several hundred million dollars in funding by October 2026; before ACE, it had ACE-Brain-0.5 exploring a unified “perception-planning-action-evaluation-evolution” cognitive loop, plus a self-developed “Kaiwu” world model. ACE-Brain-0.6 is the step to lock “spatial understanding” as the breakthrough on this embodied path.

Part One: Why “Spatial Anchoring” Is the Real Achilles’ Heel of Robot Deployment

1. From “Seeing the World” to “Locating the Target”

When designing human-robot interaction, we often treat “language—spatial perception—physical action” as a pipeline. The language model understands the command; spatial perception maps the command onto a concrete physical position; physical action executes it. General multimodal models like GPT-6 Astra do the former half well—they can “see the world”—but “locating the target” is the real watershed.

“Seeing the world” answers “what is this”; “locating the target” answers “where is it, where can I place it, where to grab, does the target even exist.” Consider:

  • The user says “put the fruit in the basket.”
  • “See the world” stage: the model identifies this is fruit, that is a basket.
  • “Locate the target” stage: the model must judge where the basket rim is, where the bearing surface is, what grasping posture to use, which direction to move, and where in the basket to place it.

High-level reasoning decides the “action strategy”; precise spatial perception decides whether that strategy can become an executable physical action. For text Q&A, a few pixels off rarely matters; but for grasping and placing, a small geometric error can collapse the entire operation chain.

2. Even Top Models Stumble on “Fine-Grained Geometric Localization”

DaXiao’s analysis notes that even a model at the apex like GPT-6 Astra still has obvious limits in fine-grained geometric localization and complex spatial-relation judgment. Consider placement tasks:

  • Placing a fruit basket requires recognizing the basket rim and the target bearing surface;
  • Folding a T-shirt requires extracting the garment contour, estimating size, and computing fold distances.

These depend not on “common sense” but on millimeter-level spatial reasoning. General models trained on internet text-image data are good at “conceptual understanding,” but for cold data like “a precise 3D position in the physical world,” their advantage can turn into a weakness.

3. Recognition Isn’t Enough: Learn to Say “It’s Not There”

A notable highlight of ACE-Brain-0.6 is its ability to recognize “nonexistent targets.” In the real world, robots often face requests to find items that aren’t in the scene at all. The model must not force out a plausible-but-wrong location; it must judge “target absent” correctly.

“A robot must be clear about what to act on, and also when not to act hastily."—that detail is easy to overlook but key to reliable physical execution.

Part Two: How ACE-Brain-0.6 Makes a 9B Beat “914B” Models

1. A Unified “Spatial-Perception Capability System”

The first thing ACE-Brain-0.6 does is integrate five spatial cognition capabilities into one unified system:

  • Object recognition: identify what a target is in the scene;
  • Multi-instance localization: when several same-class targets are in frame, find and distinguish each;
  • Spatial-relation understanding: judge “on the left,” “above,” “near which”;
  • Functional-region recognition: identify “bearing surface,” “grasping part,” “interactive region”;
  • Interaction-position prediction: predict “where to grab, where to place.”

These five used to live apart; ACE-Brain-0.6 unifies them into one model outputting “spatial coordinates, target regions, counts, judgment results” through one interface—naturally self-consistent.

2. From “Recording Physical Interaction” to “Understanding Objects and Positions”

The underlying breakthrough is redoing how “robots gain spatial cognition.”

Traditional robot data management records “continuous visual observations + action trajectories + task instructions,” but lacks fine-grained object-position, functional-region, and spatial-relation annotation. The data exists, but it “can’t be used to train spatial understanding.”

DaXiao builds a unified data-construction pipeline for embodied spatial understanding:

Robot interaction data (video/trajectories/instructions)
       │ merge 30+ open-source robot data families + private ego/first-person data
       ▼
filter keyframes by gripper state and action amplitude
       │ auto-build per-scene object vocab
       ▼
Grounding DINO + SAM 3 visual tools
       │ object localization / region recognition / semantic correction
       ▼
generate multi-type Q&A data:
  target reference / counting / spatial relation / interaction position / target-absent judgment
       │ annotation validation + answer balancing + eval-data exclusion
       ▼
~1M "verifiable" spatial-anchor training samples
(~940K distinct images + ~2.7M Q&A pairs)

The most weighty claim DaXiao keeps repeating: the key is not just data scale, but that every training answer carries a clear, verifiable visual basis. For example:

  • Only when object-instance annotations are complete is a “target counting” question generated;
  • For “target-absent” prompts, the scene must first be verified not to contain the target before the question is generated.

The goal is to avoid “wrong supervision” and “training shortcuts” as much as possible—preventing the model from gaming with lucky guesses.

3. Freeze the Vision Encoder, Move Only the Language Model

On the model side, DaXiao chose a Qwen3.5-9B base, freezing the vision encoder, and doing supervised fine-tuning on language parameters only. The bottom-layer visual feature extraction is reused directly, and the language model learns “how to translate visual information into spatial coordinates and position judgments.”

Its outputs also go through a unified interface: predicting spatial coordinates, target regions, counts, and judgment results all through one exit. This keeps training and inference clean and measurable.

Part Three: The “Log-Linear” Truth of Data Scaling, Opened with Code

1. A Counterintuitive Core Finding

ACE-Brain-0.6’s most convincing part is a controlled experiment. With the model architecture and training method completely unchanged, the team scaled training data from 260K to a million samples and observed:

  • Average score on seven public benchmarks rose from 69.3 to 74.5, in roughly log-linear growth;
  • Each doubling of training-data scale added about 2.4 points.

The more intriguing second conclusion:

Merely adding more samples of “already-existing data types” improves performance by less than 1 point; what truly drives capability growth is continuously introducing new scenes, new spatial relations, and diverse supervision forms.

In other words: it’s not “more data” that works; it’s “more diverse, more verifiable data.” Data scaling in embodied spatial perception is not crude volume-stacking but a refined engineering effort around “coverage × verifiability.”

2. Reproducing the “Log-Linear” Regularity in Python

This snippet models the log-linear growth curve and contrasts “add volume” vs “add diversity”:

# scaling_analysis.py
# Reproduce ACE-Brain-0.6's data-scaling observation:
# 1) doublings of data => ~log-linear +2.4
# 2) adding same-type samples only => +<1 point
import math

def score_by_log_scale(base_score, base_samples, samples):
    """log-linear extrapolation: every doubling => +2.4 (simplified)"""
    doublings = math.log(samples / base_samples, 2)
    return base_score + 2.4 * doublings

def same_type_add(score, extra_samples, ceiling=0.8):
    """adding only the same data type: benefit rapidly saturates"""
    return score + ceiling * (1 - math.exp(-extra_samples / 2e5))

base_score, base_samples = 69.3, 26e4

print("Paper data: 260K -> 1M samples")
print("  measured -> 74.5")
for samples in [26e4, 40e4, 60e4, 80e4, 100e4]:
    s = score_by_log_scale(base_score, base_samples, samples)
    print(f"  extrapolate {samples/1e4:.0f}w -> {s:.2f}")

print("\nStrategy comparison (both +740K samples):")
a = same_type_add(74.5, 74e4)
b = 74.5 + 2.4*math.log((base_samples+74e4)/base_samples, 2) - (74.5-base_score)
print(f"  same-type only          -> {a:.2f} (+{a-74.5:.2f})")
print(f"  introduce diverse data  -> {b:.2f} (+{b-74.5:.2f})")

Running it shows: the log-linear extrapolation hugs the measured value; while the “stack the same type” strategy quickly flattens to under 1 point—consistent with the paper—diversity is the lever of spatial-understanding ceilings.

3. Building “Negative Sampling” into the Training Loop

The “target-absent” judgment above is essentially a negative-sample / negative-sampling design:

# negative_sampling.py
# Demo: build & verify negative samples (target-absent) for spatial Q&A
class SceneValidator:
    def __init__(self):
        self.objects = {"apple", "cup", "bowl"}

    def make_q(self, target):
        if target in self.objects:
            return {"type": "locate", "answer": "found"}
        return {"type": "absent", "answer": "missing"}

    def verify(self, sample):
        real = sample["answer"] == ("found" if sample["type"] == "locate" else "missing")
        return real

v = SceneValidator()
for q in ["apple", "phone", "bowl", "chair"]:
    s = v.make_q(q)
    print(f"  ask {q:>5} -> {s['type']:>6} | verify:{v.verify(s)}")

The core point: constructing spatial Q&A data naturally treats “target not present” as a first-class citizen; whether to generate a question and whether its answer is correct must be objectively verifiable against the scene. That is the engineering skeleton of DaXiao’s “verifiable data” philosophy.

Part Four: RobotGrounding and a Look at Real Evaluation Details

ACE-Brain-0.6’s bright numbers owe much to RobotGrounding, a self-built eval set containing 2,591 questions across 14 task types, including target localization, small-object recognition, multi-instance counting, target-absent judgment, and cross-camera-view correspondence.

Because it covers hard open-environment cases like “cross-camera-view correspondence” and “target-absent judgment,” RobotGrounding better represents real robot scenarios. ACE-Brain-0.6’s 94.13, leading Astra by ~3.03, also shows the data-and-eval “spatial-understanding” orientation is self-consistent—judge by whatever standard you build data, your capability is tested under that standard.

Notably, DaXiao beat Astra on six of the eight: Where2Place (76.55 vs 71.10), PixMo-Count (89.41 vs 88.10), RoboSpatial (74.82 vs 69.55), RoboAfford (88.51 vs 84.94), ShareRobot (49.70 vs 46.60), and RobotGrounding (94.13 vs 91.10). The wins concentrate on strongly spatial tasks—placement location, spatial counting, spatial locating, interaction region, cross-embodiment sharing, real robots—exactly where “a data-trained spatial specialist” is most persuasive and where general models are relatively weak.

But keep a cool head: these evaluations mostly come from DaXiao’s own disclosures and still await independent third-party verification.

Part Five: What This Route Means for Embodied Intelligence

1. A Reference Answer to “Is a Small Model Enough?”

For a long time, embodied intelligence assumed that to reason like GPT-6 Astra you must build a huge general model to understand the physical world well. ACE-Brain-0.6 offers a counterexample: on the “spatial perception” specialist dimension, a 9B model + a million high-quality verifiable samples can form competitiveness.

Behind it lies a simple yet undervalued judgment: general models are “broad-but-shallow”; specialist models can be “narrow-but-deep.” For most robot tasks that just need “place, grab, point, locate” done right, depth beats breadth.

2. Data Isn’t Just “More,” It’s “More Verifiable”

The most worth-learning part of ACE-Brain-0.6 is its “data methodology”: build a vocab, auto-annotate with Grounding DINO and SAM 3, generate high-quality Q&A with visual basis, and block wrong supervision through validation and balancing. It proves that turning robot experience into model capability hinges not on keeping raw videos but on “translating those videos into verifiable spatial knowledge.”

3. Commercial Deployment’s Prerequisite: Getting “No” Right

“Learning to say the target is absent” directly affects commercial reliability. A robot that hard-codes coordinates for nonexistent objects in empty scenes is a disaster in real warehousing and service. ACE-Brain-0.6 making “learning to refuse” a core capability is an important step from “demo to production.”

3. Why “Comparability” Beats “Parameter Stacking”

Another easy-to-miss implication: ACE-Brain-0.6 using 9B parameters to take on top models with hundreds of billions of parameters reveals a new orientation in the embodied-intelligence industry: in a “narrow-but-deep” capability like spatial perception, “whether you can make training data diverse and verifiable” often matters more than “how many billions of parameters you have.”

For robot companies, this means evaluating an embodied foundation model shouldn’t stop at parameter count and leaderboard rank, but should weigh three hard metrics: how much “verifiable” spatial data it used, how many real scenes and spatial relations those data cover, and its performance on open-hard problems like “target-absent, cross-camera, small objects.” Pretty numbers are step one; trustworthy data is the watershed from demo to production.

4. Implication for the Open-Source Ecosystem

Finally, ACE-Brain-0.6 being fine-tuned from Qwen3.5-9B carries a plain meaning: top spatial-perception capability doesn’t have to be born only inside the walls of closed giants. A mature open-source base plus a self-built high-quality data pipeline can likewise catch up to—or surpass—closed-source titans on a narrow capability point. For teams without hundreds of billions of compute but with vast real-robot-scene data, that’s quite practical encouragement: the differentiating trump card may lie in “data engineering” rather than “model scale.”

5. A Calm Footnote

Let’s add a calm footnote: these results currently come mainly from DaXiao’s own disclosure, not yet independently reproduced by third parties; and there remains a gap between these benchmarks’ openness, task difficulty, and real robot environments. A model that wins a leaderboard isn’t the same as a robot that reliably reproduces in open cluttered environments. The spatial-perception breakthrough deserves applause, but whether the “small-model route” can be validated in broader open environments still needs time and more teams to test.

Conclusion

DaXiao ACE-Brain-0.6’s 74.53, six-above-Astra, and the “doubling data +2.4 points” log-linear curve together spell out this sentence: in embodied intelligence, a “9B small model + high-quality spatial data” route is being walked seriously.

It isn’t trying to prove “small models replace big models.” It precisely proves something else: for “aiming at the physical world and getting positions right,” the verifiability and diversity of data matter more than parameter stacking. When robots truly enter the real world to work, that step from “seeing” to “placing accurately” may be pried open one small, verifiable sample at a time.