Think While Doing or Think Before Acting? Zhiyuan Robot's GO-2 Model Provides the Answer

On April 9, Zhiyuan Robot released its next-generation VLA foundation model, Genie Operator-2 (GO-2). By introducing "action chain of thought" and an "asynchronous dual-system" architecture, it attempts to provide a new solution to the long-standing problem in robotics where perception and action are misaligned.

Over the past year, discussions around the practical deployment of robots have increased. Many consider VLA models to be a relatively direct technical path; they compress perception, understanding, and execution into a single unified model, endowing it with certain generalization capabilities.

However, as the industry gradually moves these models toward actual deployment, specific issues have become apparent. While semantic understanding, reasoning, and motion performance may appear adequate when evaluated separately, there is often a significant gap between understanding intent and stably completing tasks within concrete scenarios.

For example, after receiving a command to pick up a cup, a robot might derive a perfect path in its mental simulation, but once it begins acting, its movements easily deviate from the plan, leading to task failure. This represents a classic semantic-motion gap in robotics.

Given this discrepancy, the industry has begun rethinking whether robots should think and act simultaneously or clarify their plans before taking action.

Addressing these issues, GO-2 emphasizes that robots must think clearly before acting, thereby enhancing stability during task execution.

The key to this lies in its newly introduced action chain of thought and asynchronous dual-system architecture.

**From Fragmented Links to Action Chain of Thought

Under traditional paradigms, robots typically follow a relatively fragmented path: the high-level model completes semantic understanding and reasoning, outputting abstract instructions; then an intermediate module breaks down the tasks; finally, the control system generates specific actions.

This pipeline appears relatively smooth, but the problem lies here: there is obvious information compression and expression changes between each layer. From language to symbols, then to control signals, semantics are gradually "discretized," while action requirements demand continuous high precision.

Especially in actual deployment, to improve response speed, many systems weaken or even bypass the planning process during the execution phase, instead relying on immediate mapping from perception to action. This approach performs adequately for short-chain tasks, but once it enters multi-step, long-timeline tasks, obvious problems are easily exposed:

• Each step makes a locally optimal decision, lacking global consistency.
• Small errors are not corrected in time and thus accumulate continuously.
• Actions gradually deviate from the initial goal, ultimately leading to task failure.

On these issues, how to generate "executable" action plans and "stably execute" them in real-world environments has become the key technology.

So, a key design of the Zhiyuan GO-2 model is the introduction of an "Action Chain of Thought," completing reasoning directly in the action space rather than in language or visual spaces and then converting the results into actions. This effectively makes the "intermediate decision-making process" explicit.

Specifically, upon receiving a task, the model does not immediately output low-level control signals; instead, it first generates a high-level action sequence. This sequence is not merely a collection of commands but a structured representation of the entire task execution path, encompassing the order of behaviors, stage divisions, and overall direction.

This means that the model's thinking process itself constitutes an unexecuted action path.

With this design, complex tasks do not require decomposition through additional modules; they are naturally unfolded into a series of ordered action steps. The execution system receives not temporarily generated control signals, but already structured action plans.

The resulting shift moves the robot from an immediate-response mode of "doing while observing" to a "path formation followed by gradual execution" approach. The execution process revolves around this action sequence, allowing for local corrections of minor deviations without easily drifting from the overall goal.

In other words, planning itself serves as an executable representation, rather than an intermediate result requiring further conversion.

Decoupling Thought and Action with an Asynchronous Dual-System Architecture

In the design of GO-2, the primary focus of the action chain of thought (CoT) lies in how reasoning should be conducted and where it is placed. However, for robots, stably executing pre-planned actions in the real world is equally a critical issue that cannot be overlooked.

In many robotic systems, planning is often a one-time process: the model first generates a complete plan, and then the execution module carries it out step by step. But since real-world environments are continuously changing, this 'plan-first, execute-later' approach frequently fails mid-execution. If even a single step deviates, subsequent actions will gradually drift away from the intended path.

To address this, GO-2 introduces an 'asynchronous dual-system' architecture at the system level, decoupling 'planning' and 'execution' into two modules operating at different frequencies:

• Slow System: This component contains the action chain of thought. It does not update frequently but provides a relatively stable directional guide for movement. Rather than generating a complete plan all at once, it continuously advances, progressively unfolding the action path to ensure overall behavior remains anchored within a clear structural framework.
• Fast System: This component interacts directly with the real environment, generating control signals at a higher frequency to adjust for every detail, such as positional errors, contact variations, or external disturbances.

The key point is that the relationship between these two components is not a one-time handoff from planning to execution; rather, it functions as a continuous constraint. Execution does not merely reproduce the plan; the crucial aspect is constantly aligning with it.

In other words, each specific action must respond to the current environment without deviating from the overall trajectory. Local adjustments are permissible, but the general direction must remain intact.

To make this alignment hold in reality, GO-2 introduced a noisy forced teaching mechanism during the training phase. When training the execution module, it used real high-level action sequences as conditional inputs while artificially adding perturbations to simulate the imperfections inherent in planning.

The purpose of this step is to help the system become accustomed to the state of the real world. Even when planning is imperfect and the environment is changing, execution can proceed stably rather than quickly losing control at the slightest deviation.

Deployment Depth Is Also Part of the Model System

If we understand the previous changes as a reorganization within the system, then at the result level, GO-2 has provided relatively clear feedback: this structure is indeed working.

In several mainstream embodied AI benchmark tests, GO-2 also achieved notable results. For example, on the LIBERO Benchmark, the GO-2 model achieved an average success rate of 98.5% across four types of tasks: Spatial, Object, Goal, and Long.

However, more noteworthy than these numbers is the shift in capability they represent: the model is beginning to meet the conditions for long-term operation in real-world environments.

GO-2's approach to this is quite straightforward: it does not treat the model as a one-time training product, but rather integrates it into a continuously operating system.

On one hand, general capabilities are established through pre-training; on the other, continuous learning occurs during real-world tasks. The more the system is used and the more feedback it receives, the more the model improves.

More importantly, the deployment process itself has gradually become part of capability training. From this perspective, future standards for evaluating model capabilities may need to include the depth of actual implementation.