You bought the robot.
So what exactly is yours?
The obvious answer is:
The robot.
But that answer becomes surprisingly complicated once you look at everything inside the experience.
There is the physical machine.
There is the firmware.
There is the robot's software.
There may be a mobile app or desktop app.
There may be a cloud account.
There may be cloud AI.
There may be conversation history.
There may be memories the robot has built about you.
There may be third-party applications.
And there may be software that other people create for your robot.
You paid for the machine.
But you may not have bought all of those things in the same sense.
I think this distinction is going to become increasingly important as AI desktop robots become normal consumer products.
Because a robot that looks like one product from the outside can actually be a stack of different products and services underneath.
The physical robot is only the bottom layer
Let's start with the easy part.
You buy a robot.
It arrives at your home.
You physically possess it.
The motors, shell, cameras, speakers, sensors, battery, and other components are part of the physical product you purchased.
That feels straightforward.
And it is.
Until you ask:
What happens to everything that makes the physical machine behave like an AI robot?
That's where the clean idea of "I bought the robot" starts becoming less useful.
Pollen Robotics' current store terms are a good example.
The company lists Microduck and Reachy Mini as products sold through its store, but its terms separately state that the associated software and other commercial content remain the property of Pollen Robotics and/or Hugging Face. Certain software components are released under their respective open-source licenses, while the mechanical and electronic design files are not generally open source unless explicitly stated. (Pollen Robotics)
In other words:
buying the machine does not mean buying the intellectual property behind everything that makes the machine work.
That's not unusual.
It's just more important to understand with robots because the software can be such a large part of the experience.
You can own the hardware without owning the software
This is probably the most important distinction.
Think about your laptop.
You own the laptop.
You don't automatically own Windows, macOS, or every piece of software installed on it.
The same general idea applies to robots.
You can purchase the physical machine while using:
proprietary software
licensed software
open-source software
third-party software
all at the same time.
And those pieces can have completely different rules.
An open-source component might let you inspect, modify, or redistribute certain code under its license.
A proprietary component might only give you permission to use it.
A third-party application might have its own terms.
The robot company might retain ownership of its original software and trademarks.
That's why "Is the robot open source?" is actually too broad a question.
A much better question is:
Which parts are open, and which parts are only licensed for use?
That's a distinction I also look at when thinking about MicroDuck in How Open Is MicroDuck Really?.
Then there is the account
This is where AI robots start to feel different from older electronics.
Some connected robots require an account before they can be fully activated or used.
Vector is a very obvious example.
Current Vector setup documentation says every owner needs a Stratus account, even without a membership, and the robot is associated with that account during activation. Used Vector units can also require an ownership transfer when moving from one account to another. (ANKI)
That creates an interesting situation.
You can physically hand the robot to somebody else.
But the digital identity of the robot may still need to move with it.
That matters if you're buying second-hand.
It also matters when thinking about what ownership really means.
Is ownership:
"I have the machine on my desk."
Or:
"The machine is registered to my account."
Those are not necessarily the same thing.
And I suspect this will become more important as robots become more personalized.
Your robot may know things about you that aren't stored inside the robot
This is probably the strangest part.
Imagine your robot remembers:
your name
your preferences
previous conversations
things you asked it to remember
how you normally interact with it
You might naturally think:
"That's my robot's memory."
But where is that memory?
Inside the robot?
Inside your phone?
On your computer?
On the company's servers?
Some combination of those?
This matters.
LOOI's current privacy policy provides a useful example. The company says conversation history and its "Memory" system are stored in its cloud environment in association with the user's account. Relevant memory can then be sent to a contracted cloud AI provider together with current voice input when generating a response. Users can delete some or all of that history and memory through available controls. (LOOI)
So the robot can feel like it remembers you while the actual memory exists somewhere else.
That's an important difference between:
a robot that has memory
and:
a robot that can access memory stored by a service.
Neither model is automatically wrong.
But they create very different kinds of ownership.
This is why "my robot knows me" is a complicated sentence
Imagine you buy an AI robot and use it every day for two years.
The robot becomes familiar with you.
You have hundreds or thousands of interactions.
It learns your preferences.
You build routines around it.
Then you sell the robot.
What happens to all of that history?
Does it stay with the robot?
Does it stay with your account?
Can you export it?
Does the next owner start from zero?
Can you completely delete it?
Those questions sound theoretical today.
They won't always be.
The more personal these robots become, the more valuable their accumulated information becomes.
And that makes memory architecture an ownership issue, not just an AI feature.
I've written more about why continuity matters in Why Does an AI Desktop Robot Need Memory?.
Then there is the AI itself
Here's another layer that gets easy to miss.
Suppose your robot uses a large language model.
Did you buy that model?
Obviously not.
You're accessing a service built by somebody else.
The robot company may provide the interface.
Another company may provide the model.
A third company may provide speech recognition.
Another service may provide text-to-speech.
The robot becomes an endpoint for several different technologies.
That means the "brain" of the robot may not actually belong to the robot manufacturer.
And it certainly may not belong to you.
This creates an interesting distinction between:
owning the robot
and
owning the intelligence the robot accesses.
Those are completely different things.
It's also one reason I think the software layer will eventually become one of the most important parts of the AI robot market.
The physical machine can stay almost identical while the intelligence behind it changes dramatically.
The same thing applies to applications
This becomes even more obvious once a robot has a real software ecosystem.
Suppose you install an application that lets your robot:
play a game
or:
become a telepresence device
or:
use a different AI service
or:
perform some completely unexpected task
Do you own that application?
Probably not in the same way you own the robot.
You have access to it.
You may have a license to use it.
The developer may own the application.
And if it's community software, the project may be maintained independently from the robot company.
This is why I think the app-store question matters beyond convenience.
In Do AI Desktop Robots Need an App Store?, I looked at the problem from the discovery side.
But there is another question underneath it:
Who actually controls the software you add to your robot?
That may eventually become a major difference between robot platforms.
Open source makes the ownership picture more interesting
This is where robots such as MicroDuck become particularly interesting.
An open-source component gives users and developers rights that they might not get with a fully proprietary product.
But "open source robot" still doesn't mean:
everything belongs to the owner.
Different parts can have different licenses.
Pollen's current terms explicitly distinguish between open-source software components and proprietary commercial content, and say that mechanical and electronic design files are not generally released under an open-source license unless the documentation says otherwise. (Pollen Robotics)
So the useful question isn't:
"Is MicroDuck open source?"
It's:
"What can I legally and technically do with each part of MicroDuck?"
That's a much more useful question for both consumers and developers.
What about software you build yourself?
Now things get even more interesting.
Suppose you buy an open robot and build your own application for it.
You write the code.
You create a new behavior.
You connect an AI model.
You publish the project.
Who owns that?
Now the answer can be different.
Your own code can have its own license.
The robot's SDK can have another license.
The AI model can have another.
Any third-party API can have its own terms.
The robot becomes an environment in which several independent pieces of intellectual property interact.
This is already normal in software.
Robotics just makes the result physical.
And I think that will become increasingly important as more people start building software for consumer robots.
Cloud dependence changes the meaning of ownership again
Here's the scenario I find most interesting.
You own the hardware.
You have an account.
Your robot uses a cloud AI.
Its memory lives in the cloud.
Its applications are discovered through a manufacturer's platform.
Now imagine the company shuts that service down.
You still have the robot sitting on your desk.
So do you still have the product you bought?
Physically, yes.
Functionally, maybe not.
We've already looked at the related problem in What Happens When an AI Desktop Robot Stops Getting Software Updates?.
This is why I don't think "ownership" is enough when evaluating an AI robot.
The more useful concept is:
functional ownership.
How much of the experience can you continue using without the original company?
That's a much harder question.
Vector makes the distinction very obvious
Current Vector documentation provides a particularly clear example.
Vector can still perform some functionality without a paid membership, but the subscription is required for certain voice and AI capabilities. The company also states that without the subscription, the robot is not connected to the Vector cloud where those AI interactions happen. (ANKI)
So the physical robot doesn't disappear when the service changes.
But part of what people think of as "the robot" can.
That is the key point.
When software becomes a major part of a physical product, the boundary between:
hardware
and
service
starts to blur.
This changes how I would evaluate a robot
I don't think the useful question is:
"Do I own this?"
That's too binary.
I'd ask a series of smaller questions.
Do I control the physical hardware?
What happens if the company disappears?
Can I still use the core robot without an account?
What software can I modify?
What data can I export?
Can I delete my memories and conversation history?
Can another owner take over the robot cleanly?
Can third-party developers build on it?
Can applications continue working independently?
What depends on a cloud service?
What happens if that service shuts down?
Those answers tell you much more than a simple "open" or "closed" label.
I think this will become a major difference between robot platforms
Two robots can have similar hardware.
They can cost roughly the same.
They can even offer similar AI features.
But their ownership models can be completely different.
Robot A might give you:
hardware + local software + open APIs + community applications
Robot B might give you:
hardware + account + proprietary software + cloud AI + manufacturer-controlled ecosystem
Both are legitimate product models.
But they create different relationships between the owner and the manufacturer.
And that relationship may become more important as robots become more personal.
The most valuable part of a robot may not be the part you physically own
This is the part I find slightly counterintuitive.
When I look at a robot, the physical machine is the obvious thing.
It's what I can see.
But the longer I think about AI robots, the more I suspect their real value may accumulate somewhere else.
The hardware gives the AI a body.
The software gives it capabilities.
The cloud may give it intelligence.
The memory gives it continuity.
The community gives it new possibilities.
The manufacturer gives it an ecosystem.
And none of those things necessarily belong to the owner in the same way the physical robot does.
That doesn't make buying a robot a bad deal.
It simply means the old mental model of:
"I paid for the thing, therefore I own the thing"
isn't sufficient anymore.
So what do you actually own?
My answer would be:
You probably own the physical robot you bought.
But beyond that, ownership becomes a stack of different rights and dependencies.
You may have a license to use the software.
You may have an account that gives your robot its digital identity.
Your robot's memory may live in a company's cloud.
The AI model may belong to somebody else.
Applications may belong to their developers.
Open-source components may be governed by their own licenses.
Your own software may be yours.
And some services may only exist as long as the company behind them continues operating.
That's a very different product from a passive electronic device.
And I think consumers are eventually going to get much better at asking these questions.
Not because everyone suddenly cares about software licensing.
But because the answer affects something much simpler:
What can I still do with my robot five years after I bought it?
That's the real ownership question.
The machine on your desk is only one part of the answer.
Within this article, the internal links are already embedded at the points where they are contextually useful:
/guides/how-open-is-microduck-really → connects software licensing/open-source discussion back to the existing MicroDuck openness article.
/insights/why-does-an-ai-desktop-robot-need-memory-and-what-should-it-remember → connects ownership of memory/data to the existing Robot Intelligence article.
/insights/do-ai-desktop-robots-need-an-app-store-and-why-software-discovery-matters → connects third-party applications to the previous Robot Ecosystem article.
