Landing Page
Android APP
Agents using camara capabilities
Configuration for API Keys and models

PIRA — Physical Intelligence Runtime for Agents

It started with an old Android phone.

I'm a PhD student in Technological Innovation, and I spend a lot of time experimenting with AI agents.

One problem kept bothering me: I wanted an agent running 24/7, but keeping it alive on my MacBook meant constantly using a computer I actually needed for everything else. I was also worried about the long-term wear on its battery.

So I started looking at a second-hand Android phone as an alternative.

It was cheap, already had a battery, a camera, microphones, speakers, connectivity, and a surprising number of sensors. If I wore out its battery, it wouldn't be nearly as painful as doing that to my laptop.

But while experimenting with Android, I realized something much more interesting.

I wasn't just holding a cheap computer. I was holding a small collection of physical-world interfaces.

And there are millions of devices like it already sitting in drawers.

What if we stopped building new hardware for every AI experiment?

A lot of physical AI projects start by buying microcontrollers, cameras, microphones, sensors, and networking modules. I've worked with ESP32s and environmental sensing projects myself, so I know how quickly that adds up.

Meanwhile, an ordinary smartphone already combines many of those capabilities in one device.

That changed the question I was asking.

Instead of "How do I keep my agent running on another computer?", it became:

"What if AI agents could use the physical capabilities of devices we already own?"

That's where PIRA came from.

PIRA stands for Physical Intelligence Runtime for Agents. It's an attempt to build a reusable software layer between AI agents and real-world hardware, starting with second-hand Android phones.

The idea isn't to replace every specialized sensor. It's to stop assuming we need to manufacture or buy new hardware whenever existing consumer devices can do the job.

Infrastructure for infrastructure

I started thinking about PIRA as a missing piece in the agent ecosystem.

AI models can reason. Tools like Tavily give agents access to information on the internet. But interacting with the physical world is a different problem.

An agent might need to look through a camera, read a sensor, speak through a device, or eventually communicate with a nearby wearable.

Tavily helps agents access the web. PIRA helps them access the physical world.

I don't want every developer to have to reinvent Android permissions, hardware integrations, and device-control logic for every new agent.

I want PIRA to become infrastructure that other agents and applications can build on.

What we built

For this hackathon, we focused on an Android-first implementation and a security-first architecture.

PIRA connects AI reasoning with device capabilities through a controlled execution layer. The model shouldn't have unrestricted access to the phone just because it can generate an instruction.

Our approach separates the pieces:

The agent reasons about what the user wants.
PIRA receives a structured action request rather than blindly executing generated text.
A policy layer checks the request against the allowed capabilities.
The user remains in control of sensitive actions.
The Android runtime executes authorized operations and returns the result.

We integrated NVIDIA Nemotron through Nebius Token Factory for AI reasoning and visual understanding, and worked on connecting Tavily so an agent can combine observations from a physical device with information from the web.

For the hackathon, we're testing a small end-to-end workflow that connects Android camera input, multimodal AI reasoning through Nebius, and web research through Tavily.

The specific object being recognized isn't important. What matters is demonstrating that an agent can request a physical capability, receive information from the real world, and use that information in a broader workflow without bypassing the runtime's security boundaries.

It's a small demonstration of a much larger infrastructure idea.

It's not a complicated industrial robot. It's an everyday object, an everyday phone, and an agent trying to be genuinely useful.

That simplicity is the point.

Why security comes first

Giving an AI agent access to a physical device is exciting, but it also raises uncomfortable questions.

Who decides when the camera turns on? What can the agent access? What happens if it requests something unexpected? How do you stop it?

I don't think those questions should be postponed until after the demo works.

PIRA is being designed around explicit authorization, limited capabilities, policy checks, and human control. The goal is to make the AI useful without treating its output as a trusted command.

This is an early implementation, not a claim that we've solved every security problem in physical AI. But I believe the trust boundary needs to exist from the beginning.

Give AI access to reality. Keep humans in control.

The research behind it

PIRA didn't appear out of nowhere during a hackathon weekend.

My doctoral work and previous experiments have involved autonomous agents, environmental sensing, and the relationship between software intelligence and physical infrastructure.

Those experiences shaped how I approached this project.

I also started PIRA-Labs as a place to organize the work beyond a single application.

The organization separates the Android runtime, the website, and the research work. In particular, Pira-Research explores the wider architecture, security considerations, and possible hardware integrations.

One direction we're researching is connecting Bluetooth devices and wearables. A phone could become a gateway between an agent and other devices around a person, without every wearable needing its own AI stack.

That's a research direction, not a finished feature.

The larger vision is an ecosystem of existing devices that can become useful, permission-controlled interfaces for AI.

What was difficult

The biggest challenge was realizing that making an agent able to perform an action is not the same as making it safe to perform that action.

Android permissions, device connectivity, API credentials, camera access, asynchronous model responses, and hardware execution all have different failure modes.

Another challenge was keeping the project grounded. It's easy to imagine dozens of sensors, wearables, autonomous workflows, and future integrations. It's much harder to make one real phone complete one useful interaction reliably.

I learned to separate the long-term research vision from the functionality we could actually demonstrate.

And I learned that reusing old hardware is not only a cost-saving decision. It can change how you design the entire system.

Who is this for?

I don't imagine PIRA only being used by developers.

I imagine someone using an old phone as a small assistant at home: a device that can see something when asked, answer questions, and help with everyday tasks.

Or a small business owner repurposing a spare Android phone to help observe inventory, understand products, or retrieve relevant information without investing in a new hardware setup.

Or a researcher building an environmental monitoring experiment using devices that are already available.

These are potential applications, not products we're claiming to have completed.

What connects them is the idea that physical AI should be accessible without requiring everyone to buy a robot.

What's next

The next steps are to strengthen the Android runtime, expand the set of safely exposed capabilities, improve developer tooling, and continue researching Bluetooth and wearable integrations.

I also want to keep exploring how existing consumer hardware can support local sensing, agent workflows, and human-centered automation.

PIRA began because I didn't want to sacrifice my MacBook's battery to run an agent.

It became a much bigger question:

How much useful physical intelligence could we unlock from the hardware humanity has already built?

That's the question I'm building PIRA to explore.

Website: https://pira-ai.vercel.app/

GitHub organization: https://github.com/PIRA-Labs

Android runtime: https://github.com/PIRA-Labs/Pira-Android

Research: https://github.com/PIRA-Labs/Pira-Research