HAPTIC

From demo to deploy

Robotics deployment is hard enough. We help you go from a demo to a successful deployment.

Request access →View on GitHub
Code in your GitHubData in your Hugging Face

What is blocking your deployment?

Each card below is an example pipeline — run it as-is, fork it, or describe your own and the agent builds the recipe. Our goal is getting you deployed faster.

Shrink my model to fit a 4GB memory budget
Size

Shrink my model to fit a 4GB memory budget

Compress your policy so it loads cleanly on edge hardware without paging or OOM crashes.

Explore
Cut model size in half without breaking my evals
Size

Cut model size in half without breaking my evals

Quantize and prune aggressively, then verify task success holds on your own benchmarks.

Explore
Fit a planner and a low-level controller on one chip
Size

Fit a planner and a low-level controller on one chip

Compress both so they coexist on the same SoC without thrashing memory or compute.

Explore
Compress my policy to fit on Jetson Nano
Cost

Compress my policy to fit on Jetson Nano

Get the same task performance small enough to run on a chip that costs a fraction of Jetson Orin.

Explore
Profile my policy across candidate chips
Cost

Profile my policy across candidate chips

See exactly how small your model needs to be to fit on cheaper silicon, so the hardware team can decide with real numbers.

Explore
Compile and quantize my policy for an NPU target
Cost

Compile and quantize my policy for an NPU target

Get your model running on integrated NPUs (Hailo, Qualcomm, Rockchip) instead of a discrete GPU.

Explore
Shave 20ms off every inference step
Speed

Shave 20ms off every inference step

Hit a tighter control loop so the robot reacts before the world moves.

Explore
Hit 10Hz VLA inference on my target hardware
Speed

Hit 10Hz VLA inference on my target hardware

Get the high-level policy fast enough to drive the low-level controller in real time.

Explore
Tighten my p99 latency
Speed

Tighten my p99 latency

Kill the long tail so your robot doesn't stutter on the 1-in-100 step that ruins the demo.

Explore
Adapt my policy to a new operating environment
Finetuning

Adapt my policy to a new operating environment

Fine-tune for your lighting, clutter, and surfaces without overfitting to the demo set.

Explore
Recover task success after aggressive compression
Finetuning

Recover task success after aggressive compression

Run quantization-aware fine-tuning to claw back the accuracy you lost during compression.

Explore
Pick the right fine-tuning strategy for my situation
Finetuning

Pick the right fine-tuning strategy for my situation

LoRA, adapters, full fine-tune, replay — get a recommendation grounded in your data and compute budget.

Explore
Find the bad demonstrations hurting my fine-tune
Data

Find the bad demonstrations hurting my fine-tune

Identify low-quality teleoperation episodes before they poison the training run.

Explore
Generate synthetic data to fill gaps in my dataset
Data

Generate synthetic data to fill gaps in my dataset

Spot the failure modes your real data misses, then generate targeted synthetic episodes to cover them.

Explore
Improve my model using data from deployed robots
Data

Improve my model using data from deployed robots

Pull failure cases off the fleet, label them, and feed them back into the next fine-tune.

Explore
Generate more simulation scenarios for stress-testing
Data

Generate more simulation scenarios for stress-testing

Auto-create edge cases (lighting, clutter, novel objects) so you find policy failures in sim, not in production.

Explore
Lower watts-per-inference
Energy

Lower watts-per-inference

Compress your model so it draws less power per step, which means longer battery life, less heat, and less thermal throttling under sustained load.

Explore
Port my policy to a robot with different arm geometry
Embodiments

Port my policy to a robot with different arm geometry

Adapt the action head when link lengths, joint limits, or kinematics change.

Explore
Test the same base policy across multiple embodiments
Embodiments

Test the same base policy across multiple embodiments

Run head-to-head evals on your dev rig, pilot units, and production robot to see what transfers.

Explore
Swap grippers without retraining the whole stack
Embodiments

Swap grippers without retraining the whole stack

Fine-tune just the contact-relevant layers when end-effector hardware changes.

Explore
Monitor arXiv and Hugging Face for policies worth trying
Models

Monitor arXiv and Hugging Face for policies worth trying

Get flagged when a new VLA or base model lands that's likely to beat yours on your tasks.

Explore
Benchmark a candidate policy before committing to a fine-tune
Models

Benchmark a candidate policy before committing to a fine-tune

Run zero-shot evals on your tasks so you know if a new model is worth the GPU spend.

Explore
Get Pi0.5 running on a Jetson Orin Nano
Models

Get Pi0.5 running on a Jetson Orin Nano

Trim layers, quantize to INT8, and verify task success on commodity edge hardware instead of an A100.

Explore
Distill Pi0.5's 10-step action head into 1 step
Models

Distill Pi0.5's 10-step action head into 1 step

Apply SnapFlow-style self-distillation to cut inference passes without losing accuracy.

Explore
Fine-tune Pi0.5 on my LIBERO-style task suite
Models

Fine-tune Pi0.5 on my LIBERO-style task suite

Specialize the action expert on your data while keeping the PaliGemma backbone frozen.

Explore
Prune OpenVLA layers down to fit my hardware
Models

Prune OpenVLA layers down to fit my hardware

Cut the language model and action expert from 18 layers to 6, then recover accuracy with knowledge distillation.

Explore
Quantize my VLA to INT8 without breaking it
Models

Quantize my VLA to INT8 without breaking it

Apply weight-only quantization, validate accuracy holds, and get a 2-3x memory drop on disk.

Explore
Specialize a generalist VLA into a task-specific student
Models

Specialize a generalist VLA into a task-specific student

Distill a 3B+ frontier model into a smaller student that only needs to do your one job, reliably.

Explore

AI-native deployment...

Haptic plugs into Claude Code, Cursor, Codex, and any other agent through the MCP server, so you can fine-tune, distill, benchmark, and deploy without leaving your workflow. Hosted agents and a dashboard are there when you want them.

Terminal
$ claude mcp add haptic https://mcp.haptic.dev
Once connected:
Terminal
$ claude "Using Haptic, I want to take my Pi0.5 fine tuned checkpoint from hugging face, compress it to fit a Jetson Orin Nano, and run my evals. Show me a pipeline recommendation before kicking off the run. Budget: $40 in GPU spend."
Writes checkpoints back to your Hugging Face
Asks before spending over your budget
▶ Watch it run

...paired with real-world edge testing.

In theory, sim and silicon agree. In practice, they don't. Haptic runs every compression on real Jetsons, real NPUs, and real embodiments — the same hardware your robots ship with. We measure latency on the chip, not on a datacenter GPU pretending to be one.

Our lab — a few examples

A sample of the chips and robots we currently test on, not the full list. Bring your own hardware and Haptic learns it too.

NVIDIA Jetson Orin Nano
8GB · 15W
NVIDIA Jetson Orin AGX
64GB · 60W
NVIDIA DGX Spark
GB10 Blackwell · 128GB
Hailo-8 NPU
26 TOPS · 2.5W
Qualcomm QCS6490
12 TOPS · 5W
Rockchip RK3588
6 TOPS · 5W
Franka Research 3
7-DOF arm
LeRobot SO-100 (×4)
Low-cost manipulators
What the agent learns on your hardware
  • Which compression recipes hold up on your chip's memory bandwidth
  • Which quantization schemes your NPU compiler actually supports
  • Where the latency tail comes from (it's almost never where you think)
  • How your task's accuracy degrades as you push harder
  • Which gains transfer to your next model, and which don't

Every run feeds the recipe library. The next deploy starts further along.

Pipeline · The loop

At the edge, every bit, ounce, watt matters.

Getting a base model onto your robot — small enough, fast enough, cheap enough, good at the job — takes more than one pass. Haptic runs the loop for you.

Pre-train (labs)
Feeds into fine-tune
Prepare
1. Data
2. Sim
Modify
3. Fine-tune
4. Distill
Ship & Learn
5. Eval
6. Deploy
7. Observe
↻ Data flywheel

OpenVLA-7B · compression path

Model size

14.0 GB

Accuracy (LIBERO-Spatial)

97.0%

target chip

model

FP16

model loaded · choosing chip…

Ship the last mile

Request access →