LingBot-Touch: Tiny open-source model gives robot hands a sense of touch

What it's about

Robots have become remarkably good at seeing – but the moment they have to touch something, things often fall apart. That's the gap LingBot-Touch is aiming at. The model comes from Robbyant, a company within China's Ant Group that specializes in embodied AI (AI that lives inside robots and acts in the physical world). Robbyant open-sourced LingBot-Touch in Shanghai on November 10, 2026; the accompanying paper had already landed on arXiv on November 9 and was featured in Hugging Face's "Daily Papers" a day later.

LingBot-Touch is a so-called Tactile Foundation Model – a pretrained base model for the sense of touch that other systems can build on instead of starting from scratch every time. In demos, Robbyant shows robot hands identifying Mahjong tiles by fingertip alone, punching a straw through the sealed lid of a cup, turning a single book page, unscrewing bottle caps and pulling a cup off a stack – autonomously, according to the posts.

The size is what stands out: according to the Reddit posts linking to the project page, the tactile part of the model has a mere 5.46 million parameters – a fraction of what large language models carry around. And it is explicitly not a language model.

The problem: every sensor speaks a different language

Fitting a robot with tactile sensors doesn't mean it can actually feel anything useful. According to Robbyant's press release, commercial tactile sensors are still at an early stage, and three technical approaches are competing:

(According to shattered.io, the table describes general operating principles, not measurements from LingBot-Touch.)

So the same touch produces completely different signals depending on the sensor – sometimes an image, sometimes a handful of magnetic field values, sometimes a pressure grid. On top of that, the sensing points are laid out differently on every robot hand. If a model learns only one sensor type, its "touch knowledge" becomes worthless as soon as you swap the sensor or the hand: collect data again, retrain, re-tune. Robbyant argues that, with hardware evolving so quickly, this tight coupling keeps forcing hardware makers, robot integrators and model developers to duplicate work. Since the approaches differ in cost and use cases, the company expects them to coexist for the foreseeable future.

How LingBot-Touch works

The fix is a shared intermediate layer. LingBot-Touch has a dedicated input channel (encoder) for each sensing principle that processes the respective raw signals. The contact points from the different sensor layouts are then mapped into a shared fingertip coordinate system – a bit like overlaying city maps drawn at different scales onto the same map. A shared model then learns where contact happens, how force is distributed and how both change over time. The output is unified tactile tokens – small data packets, the same kind of "currency" language and vision models use.

Technically, according to the paper, the model is built on a JEPA architecture (Joint Embedding Predictive Architecture) with a shared Transformer. Unlike models that reconstruct their inputs point by point, a JEPA model predicts abstract representations of missing or future parts of the input – so it learns what a contact means rather than every bit of noise in the signal. Shattered.io considers this a sensible choice because tactile data is very messy due to sensor noise, temperature drift and wear on the sensor skin; that's the outlet's assessment, though, not a claim by Robbyant. According to the paper, a lightweight Vision Transformer (ViT) is enough as the backbone.

The tactile tokens are "plug-and-play": you can drop them into existing control models, such as a Diffusion Policy (a method that generates robot motions step by step from noise) or VLA models (Vision-Language-Action – models that combine images, language and actions) like π0.5 or Robbyant's own LingBot-VLA. If you already run one of these systems, you simply feed the tactile tokens in alongside the camera images and fine-tune the model.

What the model is supposed to do

The paper names four core properties:

• Unified: Data from different sensors improves the model across the board during training.
• Transferable: The model is supposed to carry over to new sensors and robot platforms without additional training.
• Efficient: Even with a small ViT backbone, fast high-frequency inference is possible – important because robots have to react in real time.
• Scalable: Performance increases with the amount of tactile training data.

Pretraining used almost 5,000 hours of real tactile data. According to the authors, experiments in simulation and on real robots show that fine-motor tasks succeed more often without compute costs exploding. The available sources, however, don't include concrete benchmark numbers.

Availability

A technical report, the code and the model resources are available on GitHub and Hugging Face. There are two variants: LingBot-Touch-Tiny and LingBot-Touch-Small. The sources don't make clear which of the two has the 5.46 million parameters mentioned. The GitHub repository is titled "Learning Heterogeneous Tactile Representation for General Dexterous Manipulation", is released under the permissive Apache 2.0 license (commercial use allowed) and, according to blockchain.news, had 103 stars at the time of reporting. It's free of charge.

What you need to try it

Compute isn't the issue here: a model with a few million parameters runs on practically any computer, even without a big graphics card, and takes up only a few megabytes. The real hurdle is the hardware around it: LingBot-Touch is only genuinely useful with real tactile sensors (magnetic, visuotactile or piezoresistive), ideally on a robot hand, or with recorded tactile data. It's not meant for chat apps like Ollama or LM Studio. If you don't own a robot, you can still study the code and paper and experiment with the released resources – but this is clearly aimed at researchers and robotics developers, not hobbyists.

The bigger picture

Touch is considered one of robotics' big blind spots: assembly, packing and household chores often fail at exactly the moment contact happens. LingBot-Touch isn't trying to build the best model for one particular sensor, but a shared representation that survives hardware changes – much like pretrained image encoders once simplified computer vision. The fact that it's released openly under Apache 2.0 matters: in a field with hardly any shared benchmarks, outside labs can now verify the claims themselves and port the model to their own hardware instead of relying on vendor demos.

Plenty of questions remain. The claim that the model transfers to new sensors without additional training is so far a vendor claim that still needs independent confirmation. Whether plugging tactile tokens into existing VLA models works as smoothly as promised will only become clear in practice, as shattered.io also notes. And while 5,000 hours of tactile data is a lot for this field, it's still small compared to the data volumes behind language or vision models. Still, the message of the demos is striking: delicate hand movements apparently don't need a giant language model – just a specialized, very small network.