Serving robot · Jetson AGX Orin · Simulation
7× higher task success rate
Task success · 100 simulated trials
Baseline: 9%ZETIC optimized: 63%
The player could not load here. Open the video
The inference company for Physical AI
More tasks.Done right.
Hardware-aware execution design for robots,
integrated into your existing stack.
The player could not load here.Open the video ↗
See faster robot executionπ0.5 · Jetson AGX Thor · Recorded comparison
Loading cooking demo…
The interactive scene couldn’t load.
Click an object to start.
Interactive demos are available on desktop.
Recorded comparisons
See the difference
in the task.
Compare task outcomes and inference performance, with the baseline and measurement conditions for each recording.
Measurement details
- Models & hardware
- Cosmos-Reason2-2B, GR00T N1.6, and gear_wbc on Jetson AGX Orin.
- Execution
- Python eager baseline → execution design combining model optimization and orchestration. The task-success comparison is baseline versus execution design.
- Task success
- The recording reports 9/100 versus 63/100 successful apple-to-plate trials with the clock running. This is a simulation result for the demonstrated setup, not a physical-robot deployment result.
- Scenario
- The serving sequence illustrates delivery, obstacles, and a spill. Execution design keeps perception running while a customer reply is generated.
- Scope
- Task outcomes depend on model execution and orchestration together. Annual totals shown are projections from the demonstrated run and trial success rates, assuming 8 hours a day, 365 days a year. They are not measured annual results. This recording does not measure energy use.
π0.5 · Jetson AGX Thor · PyTorch eager baseline
9.7× faster policy inference
Policy inference · p50
Baseline: 253.7 msZETIC optimized: 26.08 ms
The player could not load here. Open the video
Measurement details
- Model & hardware
- π0.5 · Jetson AGX Thor. Model by Physical Intelligence.
- Execution
- PyTorch eager → ZETIC hardware-aware execution optimization.
- Measurement
- Policy inference latency (p50): 253.7 ms → 26.08 ms. These values measure inference, not complete physical task duration.
- Recording
- Simulated robot actions replayed with each side’s measured inference delay; this is not a live robot recording.
- Playback
- 1× until the optimized side completes the first task, then 5× and 10×, as labeled in the recording.
YOLO26m · Jetson AGX Orin · TensorRT INT8 baseline, detection head FP16
1.6× faster object detection inference
Model latency per image
Baseline: 4.83 msZETIC optimized: 2.99 ms
The player could not load here. Open the video
Measurement details
- Model
- YOLO26m by Ultralytics.
- Measurement
- Model inference time per image, excluding the rest of the image-processing pipeline.
- Test setup
- The same 500 COCO val2017 images on each side, processed one at a time (batch size 1).
Sonata (PTv3) · Jetson AGX Thor · Stock PyTorch baseline
23.1× faster point-cloud segmentation
End-to-end latency per frame
Baseline: 715 msZETIC optimized: 31 ms
The player could not load here. Open the video
Measurement details
- Model & hardware
- Sonata (PTv3) · Jetson AGX Thor · Point-cloud segmentation.
- Execution
- Stock PyTorch FP32 with CPU voxelization → ZETIC hardware-aware execution optimization.
- Measurement
- End-to-end latency per frame: 715 ms → 31 ms (23.1×). This includes the frame-processing pipeline, not just model inference.
- Recording
- 10 Hz sensor stream. Each side shows its latest completed result; frame counters and lag relative to the sensor are shown in the recording.
- Playback
- 1× playback, as labeled in the recording.
Isaac-0.2-2B + SAM2 · Jetson Thor · FP16 full-generation baseline
10.5× faster prompt response
Prompt response
Baseline: 3.16 sZETIC optimized: 0.30 s
The player could not load here. Open the video
Measurement details
- Model & hardware
- Isaac-0.2-2B + SAM2 · NVIDIA Jetson Thor · TensorRT backend.
- Execution
- Baseline: FP16 response generation completes before coordinate output. Optimized: FP8 response generation stops at coordinates; image understanding remains FP16.
- Measurement
- Instruction submission to completed target-coordinate output: 3.16 s → 0.30 s. This is prompt-response time, not time to first token.
- Recording
- The recording shows target selection, segmentation, and tracking following a text instruction.
- Playback
- 1× real-time playback.
C-Fast-FoundationStereo · Jetson AGX Thor · Stock PyTorch baseline
2.7× faster stereo depth estimation
Latency per frame
Baseline: 104 msZETIC optimized: 38 ms
The player could not load here. Open the video
Measurement details
- Model & hardware
- C-Fast-FoundationStereo · Jetson AGX Thor.
- Execution
- Stock PyTorch FP16 → ZETIC hardware-aware execution optimization.
- Measurement
- Latency per frame: 104 ms → 38 ms (2.7×).
- Recording
- KITTI stereo frames replayed at 15 Hz, recorded at 10 Hz. Each side shows its latest completed depth map. The frame counters show skipped frames and lag relative to the camera stream.
- Playback
- 1× playback, as labeled in the recording.
The value of better execution
More work.
Better returns.
Successful trials out of 100Apple-to-plate task · Simulation
Baseline
Python eager
ZETIC
Execution design
Filled tiles: successful trials · grouped by outcome7× higher task success rate
Cosmos-Reason2-2B, GR00T N1.6, and gear_wbc on Jetson AGX Orin. View test details
Give your customers a stronger reason to buy.
Illustrative scenarioShow how better task success could lower their cost per completed task.
Same operating assumptions for both configurations. Uses the demo’s simulated success rates.
Use 1–10,000 tasks/hour and an hourly cost from $0.01 to $100,000.
Baseline$6.67
With ZETIC$0.95
86% lower modeled cost per successful task
Modeled successful tasks / hour
4.531.5
Include software, support, labor, hardware and energy in the hourly cost. No energy savings assumed.
Calculation method
Tasks/hour includes successful and unsuccessful tasks. Successful tasks/hour = tasks/hour × demo success rate. Cost/successful task = hourly operating cost ÷ successful tasks/hour. Results use your assumptions and the simulated success rates above; they are not measured physical-robot throughput, ZETIC pricing, or investment ROI.
ixian-benchPhysical AI benchmarks
Make better
inference decisions.
Compare models, hardware, and execution paths. Understand the trade-offs in latency, quality, memory, and energy use.
Compare models and execution paths
Built for your stack
- NVIDIA Jetson Thor, Orin, Nano
- Qualcomm QCS series, iQ series
Execution design
Designed for the
whole workload.
We design how your models run and work together around your hardware and task.
- 01Model graph
- 02Native kernels
- 03Runtime + state
- 04Target hardware
Optimize model execution
Reshape model graphs, tune precision, and rewrite kernels for your target hardware.
Coordinate the runtime
Plan memory, state, and model scheduling around the work your robot needs to do.
Validate the outcome
Evaluate latency, energy, and output quality against the task criteria that matter to you.
Built around your workload
From your model
to an integration package.
You bring
Model + target hardware
Your performance and quality goals.
We handle
- Baseline measurement
- Graph optimization & kernel rewrites
- Runtime orchestration & dynamic routing
- Validation & packaging
You receive
Your integration package.
- C/C++ library, ROS 2 package, or an integration tailored to your stack
- Optimized execution
- Before/after measurements
Faster, leaner inference
Optimize response time, energy use, and memory for your workload.
More from your hardware
Improve performance on your current board, or compare supported alternatives before buying.
Less optimization work
Measured results and an integration package, so your team can focus on the robot.
Two days
After the required inputs and scope are confirmed.For supported models and boards. New architectures and boards typically take about one week.
Why ZETIC
The Edge Inference Company.
We bring AI into products that run on real hardware. Today, our focus is robotics and Physical AI, built on our work in mobile and embedded inference.
Customer experience
“We were impressed by the rapid compatibility validation across our target devices. The quality and reliability of the provided results were excellent.”
Programs & recognition
Before we get started
A few practical questions.
Can you improve a workload already using TensorRT?
Yes. TensorRT can remain the backend while ZETIC optimizes your workload. We agree on the execution path and delivery format for your application.
In our Isaac-0.2-2B + SAM2 demo on Jetson Thor, typical prompt-response time fell from ~1.5 s to 0.30 s — about 5× faster, with TensorRT retained.
Watch the TensorRT-based comparisonDo we need ROS 2?
No. ROS 2 is an optional packaging choice for teams that use it. We adapt delivery to your application’s runtime and integration requirements.
Can we integrate directly with a C/C++ application?
Yes. We can provide a C/C++ library for your application without a ROS 2 wrapper. The interface and dependencies are agreed during scoping.
What baseline do the demo speedups use?
Each demo names its reference baseline and measurement conditions. A speedup against PyTorch is not a speedup against TensorRT. For your project, we agree on a relevant baseline, including your tuned TensorRT implementation when applicable.
What do you need from us?
Your model, target hardware configuration, and performance and quality goals. We confirm the scope and any validation inputs needed before work starts.
What do we receive?
Optimized execution for your workload, before/after measurements, and integration into your runtime. Delivery can include a C/C++ library, ROS 2 package, or an integration tailored to your stack.
How long does it take?
For supported models and boards, two days after the required inputs and scope are confirmed. New architectures and boards typically take about one week.
Can you help us choose hardware?
Yes. We compare supported candidates against your workload’s performance and quality requirements, so you can evaluate the options before buying each board.
Does optimization happen on the device?
Inference runs on the device. Conversion, optimization, and benchmarking can use ZETIC infrastructure before deployment. Runtime routing, where supported, selects compatible execution paths on the target device.
Which hardware can we evaluate?
Robotics projects start with supported NVIDIA Jetson and Qualcomm configurations, with coverage expanding. Compatibility is confirmed for the model, board, and runtime. For iOS and Android apps, Melange provides device benchmarking and SDK integration.
Explore MelangeWhat happens when our model changes?
The updated model is converted, optimized, and validated for its version and target hardware. Performance and output quality are checked again against the agreed criteria.
Start with your workload
Get more tasks done
on your hardware.
Tell us what you’re building, the model you’re running, and where performance is holding you back.
We’ll review your model, hardware, and goals with you to define the scope.
contact@zetic.ai