LingBot-Touch is a frozen tactile encoder for teams that already train robot policies. Our November 20 installation took 48 seconds, but the test command failed with missing model assets. Use it to evaluate prepared touch features within an existing manipulation workflow. Teams seeking a complete controller or public pretraining implementation should skip this release: it provides an encoder and feature-extraction utilities, while the action model still needs training (inference release overview, XHand action-model training account).
What people use lingbot-touch for
Robbyant reports adding frozen LingBot-Touch features to four policies across 26 real-robot tasks, with average gains of 13.9 to 24.8 percentage points over no touch. A policy chooses actions; the encoder supplies features that become part of its observations. The Humanoids Daily experiment account describes the same demonstrations being used for no-touch, raw-touch and frozen-encoder configurations, which makes the observation representation the central comparison.
| Who used it | Use case | Reported outcome |
|---|---|---|
| Robbyant research team | Added frozen features to Diffusion Policy, π0.5, LingBot-VLA and T-Rex | Average gains of 13.9 to 24.8 percentage points over no touch across 26 tasks (reported evaluation) |
| Robbyant research team | Used T-Rex and Sharpa Wave for cap twisting | 90% with LingBot-Touch, 62.5% with raw signals and 56.25% without touch (cap-twisting account) |
| Robbyant research team | Reused the encoder on XHand1 | Encoder parameters stayed frozen while the action model trained on XHand demonstrations (transfer account) |
| Robbyant research team | Trained reinforcement-learning policies in simulation | 69% across twelve tasks, versus 46% with a task-specific CNN and 21% without touch (simulation account) |
| Robbyant | Combined LingBot-VLA and LingBot-Touch for key unlocking, toothpaste dispensing and bag manipulation | Qualitative real-robot demonstrations played at normal speed (official demonstrations) |
The reported cap-twisting result separates adding touch from encoding touch. Raw signals raised the score from 56.25% to 62.5%, while LingBot-Touch features raised it to 90%. Keeping both baselines makes the encoder's contribution easier to interpret. For an adoption experiment, use the same task and policy with encoded touch, raw touch and no touch, following the structure of the reported comparison.
What happened when we ran it
Our run at commit dec8025 installed in 48 seconds and built in 1 second; tests exited 1 after 8 seconds. The November 20 measurements record 3 CPUs, 8 GB RAM and sandbox image ghcr.io/astral-sh/uv:python3.12-bookworm. The checkout contained 169 files, about 1,402 source lines and 14.9 MB. Installation and build completed before the failed test command, so these are three separate outcomes.
| November 20 check | Recorded result |
|---|---|
| Install | Succeeded in 48 seconds; 64 dependencies recorded |
| Installed disk footprint | 4,635 MB |
| Build | Succeeded in 1 second |
| Test command | Failed, exit 1, after 8 seconds |
| Pytest summary | 18 passed, 4 failed, 6 collection/setup errors; 95 subtests passed |
| Checkout scan | 169 files, about 1,402 source lines, 14.9 MB |
| Automation signals | No CI workflow files detected, no Dockerfile detected, tests directory present |
The failure log names test_cli_parses_arguments_once_for_each_input_format, test_bundles_expose_only_three_identity_routes for Tiny and Small, and test_configuration_rejects_missing_extra_or_swapped_routes. Their errors name missing checkpoint files. Six inference errors say RuntimeError: Download both model bundles before testing. Those errors cover raw-versus-normalized CLI behavior and overwrite protection, invalid normalized inputs, bilateral samples, scalar normalization and geometry, three modality routes, and zero-signal handling with padding exclusion. Pytest reported 4 failed, 18 passed, 6 errors, 95 subtests passed in 5.41s.
The separate November 21 run at dec8025b212e used a fresh unprivileged container with 2 CPUs, 4 GB RAM, no published ports and no secrets. Its clone step took 1 second. The recipe installed torch from PyPI and selected the six-line Python reader under "Run All Samples and Read the Results." Its installation size and package count belong to that recipe.
| November 21 step | Recorded result |
|---|---|
| Torch installation | torch 2.15.0 installed in 35.2 seconds (installation record) |
| Installed size | 5,255.1 MB in the venv site-packages (size record) |
| Additional packages | 28 packages besides torch (dependency record) |
| Reader snippet | Exit 1 after 5.6 seconds; missing outputs/batch_sharpa/001_left_features.pt (snippet result) |
| Recorded finding | Reader snippet failed with FileNotFoundError (recorded finding) |
| Teardown | Completed successfully (teardown record) |
The reader stopped at FileNotFoundError: [Errno 2] No such file or directory: 'outputs/batch_sharpa/001_left_features.pt' in the November 21 snippet result. The README's batch instructions first run an inference loop that writes feature files, then read one result from each output directory. The selected reader consumes an existing output; it does not generate that output itself.
Where people get stuck: bundles and geometry
The README requires matching config.json and encoder.pt files downloaded separately into the Tiny or Small checkpoint directory. Access requires an account with permission to the model repository. These model instructions separate source installation from acquiring the encoder bundle. The reader introduces another file dependency: generated features must exist before Python can load them, as the November 21 failure demonstrates.
| Where you stop | Next step | Evidence |
|---|---|---|
| Missing checkpoint configuration | Place matched model files in the documented checkpoint directory | November 20 test log and README model instructions |
| Missing batch feature file | Run the inference loop before the reader block | November 21 snippet error and README sequence |
| New sensor layout matches tensor dimensions | Prepare its geometric calibration, point order and signal axes | Input-contract explanation |
| Addressed features mix information | Use the README's attention-based querying approach | Representation guidance |
A taxel is one sensing point, and the README's geometry instructions specify a fixed transform using rotation, an origin, a reference radius and an offset. These parameters come from complete taxel geometry and reference templates. Sharpa samples already contain canonical coordinates, while the XHand adapter includes fixed coordinates and hand mappings. The README tells users to leave those example coordinates as they are rather than applying another transformation.
Three sensing families use different input routes
LingBot-Touch supports magnetic, piezoresistive and visuotactile signals through modality-specific inputs and a shared encoder. The README input instructions put magnetic measurements on three axes. Scalar piezoresistive and visuotactile measurements go in Z, with X and Y zero. Geometry and signal normalization therefore precede feature extraction; choosing the modality flag is one step in preparing a valid input.
The Sharpa example uses scalar values shaped [1,16,5,200], ordered thumb through pinky, and explicitly says these are not RGB images. The XHand example starts with [1,16,5,120,3] and selects 96 points per finger through its documented mapping. A r/LocalLLaMA post describing the interface likewise states that raw RGB images are not model inputs and describes decoded scalar visuotactile measurements.
Frozen transfer still includes policy training
The XHand account says the tactile encoder stayed frozen while the action model trained with XHand demonstrations. That distinction gives transfer a precise subject: the reused component is the encoder. The XHand training description therefore supports using pretrained tactile features within downstream training, while the researcher still prepares observations and trains the model that chooses the robot's actions.
Humanoids Daily describes three post-training configurations using the same demonstrations: no touch, raw tactile signals and frozen LingBot-Touch-Tiny tokens. The reported protocol used 200 demonstrations per task, 500 for tasks requiring both hands, and 20 consecutive evaluation trials per task. Those controls place the representation comparison inside trained policies, including a trained no-touch baseline.
LingBot-Touch vs alternatives
Humanoids Daily reports that LingBot-Touch was best in 89 of 104 task-policy pairs, below raw signals in nine and below no touch in five. Its task comparison account also reports that raw input lowered success in 22 pairs. These task-level results make raw touch and no touch useful controls even when the average encoded-touch result is higher.
| Alternative | Evidence-backed comparison | When to consider it |
|---|---|---|
| Raw tactile signals or no touch | Individual task-policy pairs favored these configurations | Keep both as controls for the intended task (reported ablations) |
| FTP-1 | Humanoids Daily reports 67.5% with FTP-1 and 82.2% with LingBot-Touch in a separate five-task LingBot-VLA test | Compare heterogeneous tactile representations (policy comparison) |
| Task-specific tactile CNN | Reported simulation results were 46% with the CNN and 69% with LingBot-Touch | Include a task-trained feature model in simulation comparisons (simulation results) |
| Sparsh | Its README names DIGIT, Gelsight'17 and Gelsight Mini | Consider its implementation and released datasets for vision-based tactile sensing (Sparsh README) |
| LingBot-Touch-Small | Small improved or held steady across reported probe-scaling steps; Tiny flattened around 4,000 hours | Compare capacity on the relevant probe task (scaling account) |
Sparsh's repository contains implementation code, pretrained models and datasets. Its downstream training instructions describe freezing the encoder and training a lightweight decoder for each task. LingBot-Touch's README emphasizes a shared representation across three sensing families. Sensor format, available datasets and the intended downstream task give researchers concrete grounds for shortlisting these projects without treating their different experiments as one scoreboard.
Apache-2.0 and the inference release
LingBot-Touch is licensed under Apache-2.0, with applicable third-party components retaining their original licenses. The README describes a frozen target encoder and feature-extraction utilities, and HotRepo's release overview explicitly says pretraining code is excluded. Downloadable weights, inference tools and source licensing describe the components an integrator can use when building a downstream experiment.
The README environment instructions name Linux, Python 3.12 and PyTorch 2.11, with commands pinning Python 3.12.13, pip 26.0.1 and torch 2.11.0. They also name numpy 2.4.4 and show CPU inference, with cuda:0 for a compatible NVIDIA GPU. The November 21 recipe installed torch 2.15.0 from PyPI, so its recorded setup differs from that documented installation command.
Repository size and maintenance signals
GitHub metadata observed on November 21 lists 789 stars, one aggregate open issue-or-PR item and a last push of November 11, 2026. The November 20 checkout scan found tests, zero CI workflow files and no Dockerfile. These are specific repository observations. The English README also links a data-interface guide and includes Sharpa and XHand examples for tracing the inference workflow.
The output contract names latent, time_id, finger_id and pos_xyz. The README output description gives latent shape [B,N,C]: N depends on frames, tubelet size and valid points, while C comes from the model configuration. Its representation guidance recommends attention-based querying because tokens mix information across taxels and time positions. An address identifies a token's location without making its contents an independent measurement of that taxel.
What the other reviews get wrong
The Robotics Media labels the 14-to-26-point improvement as a gain over raw signals, while the experiment accounts identify no touch as the comparator. Its baseline claim changes the meaning of the headline result. Latest Robot News also gives Tiny 530,000 parameters, whereas Robbyant's official project page gives the HaT-Tiny encoder 5.46 million. Baseline choice and model size are separate corrections.
AsiaTechDaily and AICoder describe FTP-1 comparisons as probing only, but Humanoids Daily also describes a separate five-task LingBot-VLA experiment, with FTP-1 at 67.5% and LingBot-Touch at 82.2% (AsiaTechDaily account, AICoder account, policy experiment account). Shattered's inability to confirm parameter counts is also narrower than the available reporting: the variant-count account gives 5.46 million for Tiny and 21.76 million for Small.
CellCog describes a repository PDF and quotes an old BibTeX placeholder, while the arXiv record dates submission to November 9, 2026. Its November 10 account captures wording it encountered, rather than establishing the report's absence from arXiv. Transfer wording needs the same precision: the XHand account describes a frozen tactile encoder alongside action-model training, as explained in the policy-training section.
FAQ
LingBot-Touch is Robbyant's pretrained tactile representation model, and its public repository supplies frozen-encoder inference tools. The README names magnetic, piezoresistive and visuotactile inputs, plus token features with time, finger and spatial addresses. For a first evaluation, the practical sequence is model-bundle download, sensor-input preparation, inference and reading the generated result. The following questions concern those components and the reported robot experiments.
What is LingBot-Touch?
LingBot-Touch converts prepared tactile signals into features for downstream models. Its README release description identifies a frozen target encoder and utilities for extracting token-level features and their addresses. A manipulation policy consumes observations and chooses actions. This division explains why installing the encoder, producing an output file and evaluating a robot policy are distinct milestones in adopting the release.
Is LingBot-Touch open source, and does the release include training code and data?
The code uses Apache-2.0, and HotRepo describes the release as inference code without pretraining code. The README links Tiny and Small weights on Hugging Face and ModelScope and requires matched configuration and encoder files. The final section addresses original-recording availability separately, so downloadable model bundles are not confused with the corpus used to train them.
Which tactile sensor types does LingBot-Touch support?
The README names magnetic, piezoresistive and visuotactile modalities. Its input instructions use three-axis magnetic measurements and scalar measurements in Z for the other two routes. The Sharpa example consumes scalar tactile values, while the XHand adapter handles handedness, point ordering and selection. These documented formats give sensor support a concrete meaning at the encoder interface.
How much does LingBot-Touch improve robot performance?
Robbyant reports average gains of 13.9 to 24.8 percentage points over no touch across four policies and 26 tasks. The Humanoids Daily results account also reports nine task-policy pairs below raw signals and five below no touch. The average gains and individual regressions answer different questions: the first summarizes the evaluation, while the second identifies variation within it.
Which robot hands was LingBot-Touch tested on?
The reported real-robot evaluation used Sharpa Wave and XHand1, with 20 tasks on Sharpa and six on XHand1. The hardware and protocol account describes dual-arm setups, four policies and 20 consecutive trials per task. Those hardware names belong to that evaluation protocol, alongside the same-demonstration comparison among no touch, raw tactile signals and frozen LingBot-Touch features.
Is LingBot-Touch free to use?
LingBot-Touch uses Apache-2.0, subject to that license and applicable third-party licenses. The README model instructions say model files are hosted separately and access requires an account with permission to the model repository. The license statement concerns the software release; sensor hardware, compute and the work of training an action policy are separate parts of an integration.
What are LingBot-Touch's limits?
The release extracts tactile features, and an action policy trains separately to use them. The XHand training account makes that division explicit by describing action-model training with a frozen encoder. The final section collects the reported hardware coverage, missing training modalities and boundaries of our software checks, keeping those adoption limits in one place.
What counts as success in each of the 26 tests?
Latest Robot News reports zipper scores of 39% without touch, 15% with raw tactile readings and 59% through LingBot-Touch. Its zipper comparison names Sharpa Wave, π0.5, the same demonstrations and 20 hardware trials for each input configuration. These are reported scores and protocol details; the final section explains the remaining gap in task-by-task scoring definitions.
How was the no-touch baseline tuned, and did tactile-equipped systems receive extra training?
All three reported configurations underwent post-training on the same demonstrations: no touch, raw tactile input and frozen LingBot-Touch tokens. The protocol account specifies 200 demonstrations per task, 500 for bimanual tasks and 20 consecutive evaluation trials per task. The no-touch baseline was therefore a trained policy within the comparison, alongside the trained tactile-equipped configurations.
How can researchers collect training data for real-world hazards without destroying robots?
LangyMD answered "3D simulations" in a Reddit exchange about collecting robot training data, and another participant disputed how well simulation represents real conditions. That r/TheMachineLearning discussion records a proposed approach. Robbyant's project page describes this model's actual corpus as tactile recordings from gloves and robot hands, rather than presenting the Reddit suggestion as its collection method.
Does a robot's model need to run locally to avoid problems when Wi-Fi drops?
The README documents CPU inference and a compatible NVIDIA GPU option for LingBot-Touch. Those device instructions identify where the encoder command runs. The broader Reddit connectivity discussion asks about fitting a robot model locally and interruptions when Wi-Fi drops. Encoder execution and the communication design of a complete robot controller are separate implementation decisions.
What changes when robots can feel as well as see?
The policy receives contact features as additional observations. Robbyant illustrates that integration through LingBot-VLA plus LingBot-Touch demonstrations of key unlocking, toothpaste dispensing and resealable-bag manipulation. The official project page labels these qualitative deployment demonstrations and says they play at normal speed. They show the project's intended use of tactile features within action selection.
What we have not tested yet
Our checks stopped at missing model assets and a missing generated feature file, without completing an encoder-output evaluation or reproducing robot-task gains. The November 21 recipe differed from the README's pinned environment. The November 20 image label records sandbox configuration rather than actual runtime or operating-system versions. Neither run measured deployment latency, working memory or robot reliability, and the revised explanation of the README sequence was not executed.
The research accounts contain no independent robot-task reproduction or common cross-project benchmark supporting an overall performance ranking. Parameter counts do not determine a controller's timing or memory requirements. The reported hardware boundaries are two tested hand embodiments, no capacitive sensors in pretraining, and underrepresented palm and finger-side contact. Broader hardware compatibility and dependable behavior beyond those conditions need separate evaluation.
The GitHub metadata contains no latest-release value, so release status is unverified. Its single aggregate open issue-or-PR count does not identify an item's type, contents or maintainer response. Public availability of the original training recordings is also unconfirmed. The readable Latest Robot News extract gives zipper scores but no five-step scoring scheme or partial-credit definition; task-wide scoring definitions for all 26 tests are not established here.
We have not assessed slip recovery, damaged objects, interrupted connections or safe behavior around people. The CPU and GPU commands do not answer whether an entire robot system tolerates Wi-Fi loss. Rendered layout, resolved links, related links, recommendation modules and template content are also outside this text revision. The next concrete adoption milestone is a saved output from a documented sample, followed by an intended-task comparison using encoded touch, raw touch and no touch.


