Key Takeaways
- The Pi API is a beta platform from Physical Intelligence for adapting general-purpose robot foundation models to your own hardware and tasks.
- You collect task demonstrations from your robot, upload the data, fine-tune a base Pi model through the hosted pipeline, and run inference on Physical Intelligence infrastructure.
- Physical Intelligence has already adapted its models with industry partners for work ranging from harvesting strawberries to assembling servers.
- There is no dedicated product page yet, so start with the company's official site at physicalintelligence.company to check beta access and current terms.
Quick Facts
| Type | Hosted API for robot foundation models |
|---|---|
| Devices | Robot hardware plus cloud training and inference |
| Price | Not published; beta access required |
| Languages | Not specified; check the official site |
| Highlight | Fine-tune Pi models on your own robot data |
| Learning curve | Moderate; needs robot data and ML basics |
| Category | AI & Models |
| Creator | Physical Intelligence |
| Official site | physicalintelligence.company ↗ |
| Heat | 🔥 412.3K Heat |
| Last updated |
What the Pi API Actually Is and Why Physical Intelligence Built It
Physical Intelligence is a robotics company that develops general-purpose foundation models for robots, meaning models pretrained to handle many tasks rather than one narrow job. The Pi API, announced in beta on October 13, 2026, is the company's way of letting outside teams adapt those models to their own machines. Instead of training a robot policy from zero, you start from a Pi model that already understands movement and manipulation, then specialize it with data from your own hardware.
The company says it has partnered with companies across diverse industries to adapt its models to their robots and applications, from harvesting strawberries to assembling servers. That range matters: it shows the same underlying model family can be pointed at soft, variable agricultural work and at precise, structured assembly. Now Physical Intelligence is opening access to more teams, which is why the Pi API is recently trending among robotics developers and automation engineers.
The core promise is practical. Building a machine-learning stack for a robot normally means data collection tooling, training infrastructure, evaluation harnesses, and deployment plumbing. The Pi API bundles training and deployment behind a hosted service, so a small team can focus on its robot and its task rather than on rebuilding that stack. The trade-off is dependence on a beta platform whose pricing, limits, and long-term support are not yet fully public.
- Foundation model, not a blank slate
You fine-tune a pretrained Pi model rather than training from scratch, which can cut the amount of task-specific data you need.
- Hosted training and inference
Physical Intelligence runs the fine-tuning pipeline and serves inference on its own infrastructure, so you do not operate GPUs yourself.
- Proven across very different tasks
Partner adaptations reportedly span strawberry harvesting and server assembly, two domains with very different tolerances for error and speed.
How Fine-Tuning and Hosted Inference Work in Practice
The workflow starts with your robot's own data. You record demonstrations of the task you want the robot to perform, typically by teleoperating it or guiding it through the motion several times. The quality and consistency of those demonstrations matter more than raw volume: clean, repeatable examples of the same task give the model a clearer signal than thousands of messy, inconsistent ones. Physical Intelligence describes uploading your robot data as the entry point to the pipeline.
Once your data is uploaded, you fine-tune a base Pi model through the hosted pipeline. Fine-tuning means the model's weights are adjusted using your examples so its behavior shifts toward your task, your gripper, your camera angles, and your workspace. You do not need to design the training loop or manage checkpoints; the platform handles that. After fine-tuning, you run inference on Physical Intelligence infrastructure, meaning your robot sends observations and receives actions through the API.
That hosted-inference model has real consequences for how you deploy. Your robot needs reliable network connectivity to the service, and latency between observation and action becomes a design constraint for anything requiring fast reflexes. For tasks where a short delay is acceptable, hosted inference removes a large operational burden. For tight control loops, you should test latency early and confirm with Physical Intelligence what deployment options exist, since the beta terms are not fully documented publicly.
- Start with a small, clean dataset
A modest set of consistent demonstrations is a better first fine-tune than a huge, noisy one, and it lets you iterate faster.
- Match the data to the deployment
Record with the same cameras, lighting, and gripper you will use in production so the fine-tuned model sees familiar inputs.
- Test latency before committing
Because inference runs on remote infrastructure, measure round-trip time for your task and confirm it fits your control requirements.
A Step-by-Step Path From Raw Demonstrations to a Working Robot Policy
The sequence below reflects how the Pi API is described: collect data, get access, fine-tune, then scale. Treat it as a practical order of operations rather than a guarantee of specific interface details, because the product is in beta and no dedicated documentation page exists yet. Confirm exact steps, limits, and supported formats with Physical Intelligence before you build a project plan around them.
One useful habit is to define a narrow first task. Instead of trying to teach a robot an entire workflow, pick one repeatable motion, such as picking an object from a known bin and placing it in a tray. A narrow task gives you a fast feedback loop, a clear success metric, and a dataset that is easy to keep consistent. Once that works end to end, expand the task or add variations rather than starting broad.
Finally, plan for iteration. Fine-tuning is rarely a one-shot process; you will likely run several rounds, adding demonstrations where the robot fails and removing examples that teach the wrong behavior. Budget time for evaluation, not just training. The teams that get the most from a platform like this usually treat data collection as an ongoing habit rather than a one-time setup step.
- Define one narrow task first
A single repeatable motion with a clear success metric gives you a fast feedback loop before you attempt a full workflow.
- Keep a failure log
Note exactly when and how the robot fails, then record new demonstrations that target those specific situations.
- Re-fine-tune rather than patch
When behavior drifts, add corrected demonstrations and run another fine-tune instead of layering manual workarounds.
Who the Pi API Suits, How It Compares, and What Remains Unclear
The clearest fit is a team that already has robot hardware and a task worth automating, but lacks the machine-learning staff to build a training and deployment stack. That includes robotics startups, research groups, and industrial automation teams exploring new processes. It is less suited to hobbyists without a programmable robot, and less suited to teams that need fully on-premises training for data-sovereignty reasons, since the pipeline is hosted.
Compared with building your own policy from open-source robot learning libraries, the Pi API trades control and transparency for speed and convenience. Compared with hiring a robotics ML team, it trades long-term cost predictability for a much faster start. The key difference from a generic machine-learning API is the domain: this is built around robot data, robot actions, and physical tasks rather than text or images, so the data you bring looks very different.
Several things remain genuinely unclear. Pricing, rate limits, supported robot platforms, data retention policies, and whether fine-tuned models can ever be exported are not established in the public announcement. Because there is no dedicated page for this title yet, the reliable move is to visit the company's official site at physicalintelligence.company, look for beta access details, and ask directly about the terms that matter to your deployment before committing.
- Best fit
Teams with existing robot hardware and a concrete task who want to skip building their own training and serving infrastructure.
- Weaker fit
Projects requiring fully local training, strict offline operation, or complete visibility into model internals.
- Open questions to verify
Pricing, usage limits, supported hardware, data handling, and model export options are not publicly settled; confirm them with the company.
Step-by-Step Guide
Check beta access on the official site
Start at Physical Intelligence's official site, physicalintelligence.company, and look for Pi API beta details or a contact route. There is no dedicated product page yet, so you may need to reach out directly. Ask about eligibility, supported hardware, and current terms before planning further.
Collect clean task demonstrations
Record your robot performing one narrow, repeatable task several times, using the same cameras, lighting, and gripper you will use in production. Aim for consistency over volume. A small, tidy dataset is a better first fine-tune than a large, messy one.
Upload your data and fine-tune a base Pi model
Provide your dataset through the hosted pipeline and run a fine-tune on a base Pi model. The platform handles the training loop and checkpoints, so your job is to supply good examples and specify the task clearly. Confirm supported data formats with the company first.
Evaluate the fine-tuned policy on your robot
Run the model on your hardware and measure success rate on the exact task you trained for. Note every failure and the conditions that caused it. This evaluation round tells you whether to add data, narrow the task, or adjust your setup.
Iterate, then scale toward deployment
Add demonstrations that target observed failures and run another fine-tune, repeating until performance is stable. Then test latency and reliability for real operating conditions. Only after that should you expand to additional tasks or move toward full deployment.
Frequently Asked Questions
What exactly is the Pi API?
It is a beta platform from Physical Intelligence that lets developers adapt the company's general-purpose robot foundation models to specific machines. You upload your own robot data, fine-tune a Pi model through a hosted pipeline, and run inference on Physical Intelligence infrastructure. In effect, it packages training and deployment so teams do not have to build a robotics machine-learning stack from scratch.
How much does the Pi API cost, and is there a free tier?
Pricing has not been published in the public announcement, and the platform is described as a beta release with access opened to more teams. That means commercial terms, usage limits, and any free allowance are not yet established publicly. Check the official site at physicalintelligence.company or contact the company directly for current pricing and beta conditions.
What kind of robot data do I need to fine-tune a model?
You need demonstrations of the task you want the robot to perform, recorded on the hardware you intend to deploy. Consistency matters more than sheer volume, so use the same cameras, lighting, and gripper as production. Start with one narrow, repeatable task so you can measure success clearly and iterate quickly before expanding.
Does inference run on my hardware or in the cloud?
The Pi API is described as running inference on Physical Intelligence infrastructure, so your robot sends observations and receives actions over the network. That removes the need to operate GPUs yourself, but it makes connectivity and latency design constraints. For tasks needing very fast reflexes, measure round-trip time early and confirm deployment options with the company.
How does this compare with training my own robot policy?
Training from scratch gives you full control and transparency but requires data tooling, training infrastructure, evaluation harnesses, and deployment plumbing. The Pi API trades some of that control for speed, since you start from a pretrained model and use a hosted pipeline. Which is better depends on your team's ML capacity and how much you need to inspect or export the model.
