PAPER DEEP DIVE
Social Humanoid: Socially Responsive Human-Humanoid Interaction
Humanoid robots are typically trained as solitary agents, leaving them unable to coordinate physically with human partners who naturally anticipate and adjust to one another. To bridge this gap, we present Social Humanoid, a hierarchical system that generates and executes socially responsive whole-body motion on a 29-DoF Unitree G1 conditioned on a human partner's motion. Its high-level policy performs flexible sequence modeling of human and humanoid motion through a shared tokenized representation, generating reactive humanoid motion and anticipating the partner's motion when they are occluded, while a low-level whole-body tracking controller executes the generated motion on the robot. To train the system, we introduce a two-phase adaptive retargeting procedure that retargets one interaction partner to the robot while morphing the other partner to preserve contact dynamics, reachability, and relative body scale. We apply this procedure across five motion-capture datasets to produce a new Human-Humanoid Interaction (HHI) benchmark of 260 hours of human-humanoid interactions. Our results demonstrate that Social Humanoid produces coordinated, human-aligned behavior across diverse interaction types in simulation and the real world. Project page: https://von31.github.io/social-humanoid/
One-sentence summary
The paper retargets human–human interaction data to a 29-DoF Unitree G1, learns a shared human–robot motion vocabulary, predicts both partners with a Diffusion Forcing Transformer, and executes the resulting whole-body response through SONIC at 50 Hz.
Why social interaction is a different robotics problem
A humanoid that can walk steadily and pick up an object is not yet prepared to greet someone, return a high-five, or accept a hug. Social interaction requires the robot to infer what the other person is likely to do, choose a whole-body response that respects its own morphology, and update that response as the person moves. The two bodies are coupled: the robot’s movement changes the human’s available space, and the human’s reaction changes what counts as a successful robot action.
Most human–human motion generators are evaluated as offline animation systems. They can produce two plausible skeletons over a fixed time window, but they do not have to explain whether the result is reachable by a physical robot, whether the feet can remain planted, or whether a low-level controller can track the result without falling. Conversely, humanoid motion retargeting and whole-body control methods can produce executable trajectories from a person, but their inputs usually describe one actor and do not contain a partner whose future behavior must be anticipated.
Social Humanoid joins those two lines of work. Its output is not a single “social animation.” It is a rolling stream of humanoid references produced from an RGB-D observation of a human partner, passed to a tracking controller, and updated as new observations arrive. The paper therefore evaluates three linked questions: can human–human contact be preserved when one actor becomes a G1, can the learned model generate a coordinated response rather than an isolated motion, and can the complete pipeline run on real hardware with acceptable latency?
The morphology gap creates a particularly awkward data problem. If the robot is retargeted independently, its shorter arms may no longer reach the partner’s hands. If the entire pair is scaled down, the partner becomes an unrealistically small human and the training distribution no longer resembles the adults the robot will meet. The paper’s solution is not to hide this mismatch inside a learned black box. It first retargets the active human to the robot, then adjusts the partner’s pose and arm configuration to restore contact while keeping the partner’s human scale.
The real-time requirement adds another constraint. Camera capture, person tracking, human pose estimation, network transport, diffusion sampling, and low-level control all sit on the same causal path. A response that arrives several frames late may still look smooth in an offline plot, but it can miss the moment when a hand is offered. The reported 308 ms median command latency is therefore part of the method’s empirical claim, not an implementation footnote.
Figure 1 in the paper: the G1 participates in a hug and a greeting, then holds a pose with the person for a photograph.
The HHI benchmark and motion representation
The authors build a human–humanoid interaction benchmark from CHI3D, Hi4D, Harmony4D, Inter-X, and Embody3D. All source clips are retargeted to the Unitree G1 and resampled to 30 FPS. The supplementary table reports 245 clips and 0.24 hours for CHI3D, 200 clips and 0.22 hours for Hi4D, 416 clips and 1.42 hours for Harmony4D, 22,776 clips and 37.50 hours for Inter-X, and 14,692 clips and 220.97 hours for Embody3D, totaling about 260 hours.
Each dyadic clip is retargeted twice with the ego and partner roles exchanged. This is not a cosmetic data-augmentation step. It prevents the model from learning a fixed social script in which the human always initiates and the robot always follows. After role exchange, the same geometry can appear as a robot-led initiation or a robot response, which is necessary for a policy that must handle both directions of interaction.
The representation is relative and canonical rather than tied to world coordinates. Human motion uses 21 SMPL joints in 6D rotation form, while the G1 uses 29 actuated joint angles. Root motion is encoded as a relative canonical transform between consecutive frames. The representation also keeps the canonical-to-root transform and the transform from one agent to the other, so the network sees both local body configuration and the spatial relation between the two people.
For agent $a$ with partner $b$, the per-agent motion vector is:
$$ \mathbf m^{a}=\left[\Delta\mathbf T^{\mathrm{can},a};\mathbf T^{\mathrm{can}\to\mathrm{root},a};\Theta^{a};\mathbf T^{a\to b}\right] $$
The first block stores relative root rotation and translation, the second places the canonical pose in the root frame, the third stores embodiment-specific articulation, and the last encodes the partner’s relative transform. This design avoids making the model memorize absolute room positions. Two people performing the same handshake in different locations can share a representation, while a change in their relative distance remains visible to the model.
The representation also separates what is shared from what is embodiment-specific. Human and robot joint angles are not forced into a common dimensionality; they are encoded by separate networks and only meet in a discrete codebook. The relative transforms give both encoders a common geometric context without pretending that a G1 elbow has the same kinematics as a human elbow.
Shared-codebook VQ-VAE
Social Humanoid needs a compact, streaming representation for two motion spaces that have different dimensions and different meanings. The paper uses a VQ-VAE with 1D convolutional encoders, temporal downsampling by four, dilated residual blocks, separate decoders, and a single EMA codebook shared by human and robot. The encoder outputs are continuous latent sequences; quantization assigns each frame token to the nearest codebook entry:
$$ \mathbf z_t^{a}=\arg\min_{\mathbf c_k\in\mathcal C}\left\|\mathbf v_t^{a}-\mathbf c_k\right\|_2 $$
Because only the codebook is shared, the human decoder reconstructs SMPL motion and the robot decoder reconstructs G1 motion from the same discrete vocabulary. A code can therefore mean “left arm reaches forward” without requiring the two bodies to have identical joint angles. The shared vocabulary is a semantic bottleneck, not a shared skeleton.
A shared codebook by itself is not enough. Without an objective that ties corresponding frames together, the human encoder and robot encoder can occupy different regions of the codebook even when their motion is semantically paired. The paper adds a continuous alignment term that pulls paired encoder features together:
$$ \mathcal L_{\mathrm{align}}=\left\|\mathbf v^{\mathrm h}-\mathbf v^{\mathrm r}\right\|_2^2 $$
It also converts the distance from each feature to each code into classification logits and applies symmetric cross-entropy. The human branch is trained to predict the robot branch’s selected code, and the robot branch is trained to predict the human branch’s code:
$$ \mathcal L_{\mathrm{agree}}=\frac{1}{2}\left[\mathrm{CE}\left(\ell^{\mathrm h},c^{\mathrm r}\right)+\mathrm{CE}\left(\ell^{\mathrm r},c^{\mathrm h}\right)\right] $$
The full objective combines reconstruction, VQ commitment, and both alignment terms:
$$ \mathcal L=\mathcal L_{\mathrm{rec}}+\beta\mathcal L_{\mathrm{commit}}+\lambda_{\mathrm{align}}\mathcal L_{\mathrm{align}}+\lambda_{\mathrm{agree}}\mathcal L_{\mathrm{agree}} $$
The ablation makes the difference concrete. With no alignment, self-reconstruction is already good: 3.665 cm for the human and 2.809 cm for the robot. Yet human-to-robot translation has 12.520 cm MPJPE and paired frames share a code 0% of the time. With continuous and discrete alignment together, translation drops to 2.793 cm, code agreement rises to 0.780, and human-to-robot Fréchet Distance falls from 0.2062 to 0.0028. The learned vocabulary is useful only when its entries are forced to mean compatible things across embodiments.
Figure 3 in the paper: separate embodiment encoders and decoders share one discrete codebook; continuous and discrete alignment make paired frames map to compatible codes.
Diffusion Forcing Transformer for dyadic prediction
The high-level policy receives a history of human and robot latent tokens and predicts future latents for both agents. The model is a Diffusion Forcing Transformer because each future token can receive its own noise level. Human and robot tokens are not forced to share the same diffusion timestep, which blocks a shortcut in which the network could infer one agent’s clean state from the other agent’s noise level.
For agent $a$ and future index $i$, the noisy token is:
$$ \mathbf z_i^{a}\left(t_i^{a}\right)=\sqrt{\bar\alpha_{t_i^{a}}}\mathbf z_i^{a}+\sqrt{1-\bar\alpha_{t_i^{a}}}\epsilon_i^{a} $$
The transformer combines the noisy latent with a sinusoidal noise-level embedding, a temporal position embedding, and an agent embedding. Context tokens remain clean, while future tokens can be noised independently. The model is trained to recover clean latents and is evaluated with a Smooth-L1 objective in latent space.
At inference time the system uses deterministic DDIM over 30 steps. A sampling strategy matrix controls the noise level of every agent–time token during denoising. Different schedules let the same model perform joint future generation, partner prediction, or partner inpainting without retraining. For reactive operation, observed human tokens can remain conditioned while the robot future is generated; for planning, both futures can be generated jointly.
The total training objective spans three spaces:
$$ \mathcal L_{\mathrm{total}}=w_{\mathrm{latent}}\mathcal L_{\mathrm{latent}}+w_{\mathrm{motion}}\mathcal L_{\mathrm{motion}}+w_{\mathrm{recon}}\mathcal L_{\mathrm{recon}} $$
The weights are 1 for latent denoising, 0.5 for motion-space loss, and 0.5 for reconstruction. The latent term keeps the diffusion trajectory accurate. The motion term decodes predicted tokens and compares the resulting poses with ground truth, which prevents a low latent error from hiding an unusable kinematic output. The reconstruction term sends clean motion through the non-diffused autoencoder and enforces a useful bottleneck. Each term addresses a different failure mode of the combined representation.
This design is well matched to streaming interaction. The model can retain a clean observed history, generate several future robot tokens, and leave human future tokens partially observed or unspecified. The policy does not need a separate “intent classifier” followed by a motion generator. Human prediction and robot response are represented as different conditional slices of the same denoising problem.
flowchart LR
OBS["RGB-D observation"] --> POSE["Fast SAM 3D Body
and global tracking"]
POSE --> REP["Canonical dyad
motion representation"]
REP --> ENC_H["Human encoder"]
REP --> ENC_R["Robot encoder"]
ENC_H --> BOOK["Shared discrete
codebook"]
ENC_R --> BOOK
BOOK --> POLICY["Diffusion Forcing
Transformer"]
POLICY --> FUT_H["Future human
tokens"]
POLICY --> FUT_R["Future robot
tokens"]
FUT_R --> DEC_R["Robot decoder"]
DEC_R --> TRACK["SONIC whole-body
tracking at 50 Hz"]
TRACK --> G1["Unitree G1"]
G1 --> REP
Adaptive-HHI retargeting
The training data cannot be produced by independently retargeting each person. When the active human is converted to a G1, the robot’s hand may no longer reach the unchanged partner. The paper therefore uses a two-pass optimization. Pass I follows OmniRetarget’s SQP and interaction-mesh formulation and solves for a 36-dimensional robot configuration: 29 actuated degrees of freedom plus a 7D base pose.
The Pass I objective is:
$$ \min_{\mathbf q_t}\sum_v w_v\left\|\mathcal L\left(\mathbf x_t\left(\mathbf q_t\right)\right)_v-s\mathcal L\left(\mathbf x_t^{\mathrm{src}}\right)_v\right\|^2+\sum_{j\in\mathcal P}\lambda_j\left(r_{j,t}\left(\mathbf q_t\right)-d_{j,t}\right)^2+\lambda_s\left\|\mathbf q_t-\mathbf q_{t-1}\right\|^2+\mathbf q_t^{\top}\mathbf Q\mathbf q_t $$
The Laplacian term preserves local interaction-mesh shape after scaling by the robot-to-human height ratio. The distance term preserves wrist and elbow distances to the partner, with larger weights on wrists because they carry most contact in the benchmark. Temporal smoothness and posture regularization keep the solution stable, while hard constraints enforce joint limits, a trust region, and foot sticking. Contact-aware grounding further separates stance from airborne phases rather than pinning the feet to the floor at every frame.
Pass I can still leave the partner reaching above the shorter robot’s shoulders or holding an arm in a pose that no longer makes sense at the new scale. Pass II co-morphs the partner. For frames with robot-arm contact, it runs arm-chain IK over the partner’s shoulder, elbow, and wrist while respecting human joint limits. For high-contact segments, it solves a body QP over wrist, chest, and neck clusters, allowing the partner’s hips, spine, and knees to adjust while preserving human proportions.
The phrase “adaptive” is important because the partner is not uniformly rescaled. A uniform scale would make the robot and human geometrically compatible but would create a miniature person unlike anyone the deployed robot will meet. Adaptive-HHI changes pose and reach, not the partner’s height. The robot absorbs the morphology gap first; the human pose then makes the remaining contact relationship attainable.
Figure 4 in the paper: Pass I retargets the ego human to the G1; Pass II co-morphs the partner’s pose under contact constraints.
The retargeting ablation isolates the contribution of the two additions. On CHI3D, contact-adaptive weights reduce wrist error from 1.379 cm to 0.976 cm and raise contact preservation from 0.915 to 0.933, but worsen foot skating from 0.009 to 0.014. Adding contact-and-reach preservation lowers wrist error to 0.501 cm, raises contact preservation to 0.936, and reduces foot skating to 0.0034. The largest gain comes from preserving the interaction distances directly, not merely from weighting nearby body regions.
Perception, generation, and execution on the G1
The physical system uses a tripod-mounted ZED 2i at 1280×720 and 15 Hz. YOLOv11 detects people, Fast Sam 3D Body estimates SMPL pose, stereo depth recovers metric root position, and RANSAC fits a ground plane to obtain gravity direction and floor height. A constant-velocity Kalman filter smooths the human trajectory and the Hungarian algorithm maintains identities across frames.
The robot is localized with AprilTags during initialization. Onboard Unitree state estimation supplies the relative robot motion afterward, and the two estimates are composed into a common gravity-aligned frame. RGB is JPEG-compressed and depth is Zstd-compressed for network transport. Human estimation runs on two remote RTX 4090 GPUs, the high-level policy on another RTX 4090, and SONIC on a local RTX 4060 Mobile.
The pipeline interpolates human observations from 15 Hz to 30 Hz, runs DFoT, emits 30 Hz motion chunks at 7.5 Hz, and lets SONIC interpolate and track at 50 Hz. The reported end-to-end command latency has a 308.1 ms median and 376.2 ms p95. With one-chunk postprocessing delay and a 100 ms execution buffer, the median rises to 541.1 ms and p95 to 609.2 ms. The optional buffering improves continuity but directly increases the delay between a person’s movement and the robot’s response.
| Pipeline stage | p50 [ms] | p95 [ms] |
|---|---|---|
| Perception, transport, and synchronization | 104.4 | 120.4 |
| Human pose and global estimation | 79.4 | 115.6 |
| High-level VQ-VAE and DFoT pipeline | 103.2 | 118.2 |
| Low-level SONIC and robot transport | 21.1 | 22.0 |
| Minimum end-to-end total | 308.1 | 376.2 |
| With optional buffers | 541.1 | 609.2 |
Safety is staged from simulation to a gantry-supported robot and then to a free-standing G1. SONIC holds a standing pose until a dedicated operator enables execution. The desired yaw rate is clamped at 45 degrees per second, and the system returns smoothly to standing if consecutive high-level predictions differ by more than 0.7 rad or the operator decides that the behavior is unsafe. Five 60-second rollouts produced no unsafe generated behavior, but the controller is not force-adaptive or force-compliant, so physical contact is not actively regulated.
Figure 6 in the paper: high-five and wave trials above; a continuous handshake-to-bend trial below.
High-level policy results
Table 1 compares the generative policy with nearest-neighbor retrieval, random sampling, and Ready-to-React on the HHI benchmark. Social Humanoid obtains 0.128 W-MPJPE, compared with 0.545 for R2R and about 1.10 for NN and RS. Its MPJVE is 0.007, the lowest in the table. The more distinctive result is motion interaction error: 0.002 versus 0.056 for the retrieval baselines and 0.088 for R2R.
| Method | FD ↓ | FS ↓ | IP ↓ | MI ↓ | MPJVE ↓ | W-MPJPE ↓ |
|---|---|---|---|---|---|---|
| NN | 0.053 | 0.138 | 0.057 | 0.056 | 0.014 | 1.099 |
| RS | 0.180 | 0.134 | 0.058 | 0.056 | 0.015 | 1.100 |
| R2R | 0.504 | 0.921 | 0.088 | 0.088 | 0.019 | 0.545 |
| Ours | 0.118 | 0.876 | 0.051 | 0.002 | 0.007 | 0.128 |
The table does not show a universal win. Nearest-neighbor retrieval has better FD and foot skating because it replays real training windows with valid contacts. That advantage is expected: a retrieval system can preserve local physical plausibility while failing to choose the correct reaction. The proposed model has worse FS than NN and RS, but much lower positional and interaction error. This tradeoff is central to the paper’s claim. For social interaction, a plausible isolated motion is not enough if it reacts to the wrong partner state.
The VQ-VAE ablation separates the value of discrete tokenization from the value of sharing. Removing VQ-VAE produces FD 0.253 and IP 0.027. Using separate codebooks produces IP 0.088 and MI 0.212, worse than the shared version’s IP 0.026 and MI 0.019. The shared-codebook model also obtains FD 0.072, MPJVE 0.005, and W-MPJPE 0.057. The result supports a specific interpretation: a discrete bottleneck helps regularize generation, but only a vocabulary with cross-embodiment agreement supports coherent dyadic prediction.
Retargeting and real-robot evidence
Adaptive-HHI is compared with PHC and OmniRetarget on CHI3D, Hi4D, and Harmony4D. It has the lowest pose distortion, highest contact preservation, lowest foot skating, and lowest wrist error on all three datasets. Wrist error is 0.501 cm versus 1.379 cm for OmniRetarget on CHI3D, 0.804 versus 1.729 cm on Hi4D, and 1.909 versus 2.981 cm on Harmony4D. PHC remains above 20 cm on every dataset.
| Dataset | Method | MPJPE [cm] ↓ | Contact ↑ | Foot skating ↓ | Wrist error [cm] ↓ | Policy success ↑ |
|---|---|---|---|---|---|---|
| CHI3D | PHC | 6.179 | 0.478 | 0.107 | 22.382 | 68% |
| CHI3D | OmniRetarget | 4.184 | 0.915 | 0.009 | 1.379 | 100% |
| CHI3D | Ours | 3.893 | 0.936 | 0.003 | 0.501 | 100% |
| Hi4D | PHC | 6.892 | 0.089 | 0.087 | 21.088 | 79% |
| Hi4D | OmniRetarget | 4.704 | 0.827 | 0.006 | 1.729 | 100% |
| Hi4D | Ours | 4.371 | 0.881 | 0.005 | 0.804 | 100% |
| Harmony4D | PHC | 7.656 | 0.215 | 0.291 | 23.365 | 62% |
| Harmony4D | OmniRetarget | 5.220 | 0.676 | 0.033 | 2.981 | 81% |
| Harmony4D | Ours | 4.638 | 0.775 | 0.020 | 1.909 | 97% |
The downstream success rate turns the geometric metrics into a control outcome. On Harmony4D, the proposed retargeting reaches 97% while OmniRetarget reaches 81% and PHC reaches 62%. A wrist offset of a few centimeters in the reference can become a missed contact or an untrackable arm configuration. On CHI3D and Hi4D, both the proposed method and OmniRetarget reach 100%, showing that the retargeting advantage is smaller when the source interaction is already close to the robot’s geometry. Harmony4D stresses the method more because it contains wider in-the-wild variation.
Figure 5 in the paper: original human–human contact sequences and their retargeted humanoid–partner counterparts across varied interactions.
Real-robot and simulation tests cover six scenarios with 30 trials each. In simulation, success means tracking without a fall or unsafe behavior. On the real G1, success means producing the appropriate reaction and completing the interaction without operator intervention. Handshake, wave, hug, bend, and linked-arms all reach 100% in both settings. High-five reaches 90% in both. The real results match simulation exactly, which suggests that the main failures occur in the generated reference rather than in an unexpected sim-to-real collapse of the tracker.
| Interaction | Simulation | Real G1 | Trials |
|---|---|---|---|
| Handshake | 100% | 100% | 30 |
| Wave | 100% | 100% | 30 |
| High-five | 90% | 90% | 30 |
| Hug | 100% | 100% | 30 |
| Bend | 100% | 100% | 30 |
| Linked arms | 100% | 100% | 30 |
These rates measure task completion, not social quality. They do not answer whether the participant felt comfortable, whether the robot approached at an appropriate speed, or whether eye contact and timing made the behavior legible. High-five is especially informative: it is fast, spatially precise, and contact-heavy, and it is the only scenario below 100%. A system can appear robust in a hug while still missing the brief window in which a palm is offered.
Shadow teleoperation as a representation test
The shared codebook supports a second use: direct human-to-robot translation. The system encodes the operator with the human encoder, quantizes the latent against the shared codebook, and decodes it with the robot decoder, without robot history or optimization-based retargeting. The paper demonstrates the G1 shadowing arm movements and sitting down on a couch. The robot follows through its own kinematics rather than copying joint angles one-to-one.
This is a useful test because it removes the DFoT and low-level policy from the cross-embodiment mapping. If the codebook had only compressed each embodiment independently, the translated motion would be semantically wrong even when each decoder reconstructed its own data well. The reduction from 12.520 cm to 2.793 cm MPJPE after alignment shows that the common vocabulary carries transferable meaning. Shadow teleoperation is therefore not a separate application bolted onto the paper; it is evidence that the shared representation has learned a cross-embodiment correspondence.
Author-stated limitations and independent concerns
The authors state that the system does not model hand articulation, facial expression, or object pose. This excludes finger-level grasp, facial response, and manipulation of a shared object. A hug can be executed as a whole-body trajectory while the hands remain semantically empty; a handshake can preserve wrist proximity without producing a convincing grip. These are not small omissions for social interaction because they carry much of the meaning and safety-relevant intent.
The method relies on off-the-shelf human pose estimation, global human tracking, and the SONIC controller. The contribution is the data transformation, shared representation, and high-level dynamics rather than a robust perception stack or a force-aware low-level policy. Occlusion, fast crossing motion, identity swaps in multi-person scenes, and depth errors can propagate into the generator. The paper does not isolate how much of a failed real trial is caused by perception, codebook quantization, diffusion prediction, or tracking.
The high-level model and retargeting are kinematic. SONIC makes the reference executable, but the system does not explicitly optimize interaction force, human comfort, pain thresholds, or social distance. Safety is addressed through operator supervision, yaw limits, prediction-consistency checks, and return-to-standing behavior. The supplementary material explicitly notes that the low-level policy is neither force-adaptive nor force-compliant. Avoiding a fall is necessary but not sufficient for a safe physical interaction with a person.
The real evaluation uses four participants, 30 trials per scenario, and six predefined interactions. It establishes feasibility but does not estimate variation across age, height, culture, familiarity with robots, or unexpected human behavior. The system is dyadic: it maintains one selected human track and does not solve partner selection, shared attention, turn-taking, or coordination among several people. Those are central requirements for a social robot in a room rather than a controlled two-person stage.
An independent concern is latency under faster interactions. A 308 ms median is meaningful for a deliberate hug or wave, but it may be too slow for a rapid high-five, evasive step, or reaction to a stumble. Buffering reduces jitter but increases the delay to 541 ms in the optional configuration. The paper reports the tradeoff honestly; it does not establish a control regime that is simultaneously contact-rich, highly dynamic, and low-latency.
What the work changes
The first contribution is to treat human–humanoid data generation as a paired geometric problem. Retargeting the human first and co-morphing the partner second avoids both independent retargeting and unrealistic pair scaling. The wrist-error reduction and the Harmony4D downstream improvement show that contact geometry is not a cosmetic preprocessing detail. A reference that misses the partner’s hand cannot be repaired by a better diffusion model downstream.
The second contribution is a shared discrete motion vocabulary that supports both conditional generation and direct translation. The codebook is not simply a compression trick; the alignment losses make corresponding human and robot motions occupy the same semantic units. The same representation can drive human-to-robot shadowing without optimization, while DFoT uses it to predict a coordinated future. This is a practical way to handle heterogeneous embodiments without forcing a one-to-one joint mapping.
The third contribution is the end-to-end evidence chain. The paper connects retargeting metrics, generative metrics, simulation success, real-robot success, and latency. That structure makes the limitations visible: a low MPJPE does not guarantee a good social response, a perfect simulator rollout does not guarantee human comfort, and a visually plausible animation does not guarantee 50 Hz executability. The system is not a complete social intelligence, but it demonstrates that coordinated whole-body interaction can be represented, generated, and executed as one pipeline.
Conclusion
Social Humanoid combines Adaptive-HHI retargeting, a shared-codebook VQ-VAE, a Diffusion Forcing Transformer, and SONIC tracking to produce socially responsive whole-body behavior on a Unitree G1. The benchmark contains roughly 260 hours of retargeted human–human interaction. The model outperforms retrieval and R2R on positional, dynamic, interpenetration, and interaction metrics, while the retargeting method reduces wrist error and improves downstream policy success on three interaction datasets.
The next technical steps are clear from the limitations: add hands, face, object state, and contact force; evaluate with more people and more diverse social scenarios; and reduce latency without sacrificing motion continuity. Public code and data are still pending, so reproducibility remains an open condition. Even so, the paper makes a strong architectural point: in heterogeneous embodied interaction, a shared representation must be tied to contact geometry and executable control, otherwise it remains an animation representation rather than a robot capability.
Golden line: A social humanoid does not need to copy a person’s joint angles; it needs a shared motion vocabulary for understanding what is happening and deciding how to respond.
