👁️ MyZubster Robots Now See: Smart Camera Integration Complete!
Open Source · XMR Payments · 26 Robot Projects · Computer Vision · AI · TAZ DAY #1
The MyZubster robotics ecosystem has reached another important milestone.
The robots can now see.
We have integrated a reusable Smart Camera module into the ecosystem, opening the door to computer vision, object detection and vision-based robot decisions.
The first applications focus on two concrete examples:
🤖 Fluffypony Smart can check whether a glass is present before serving.
🛡️ Hera Security Vision can analyze a camera feed and detect people during a patrol.
This changes the architecture significantly.
Previously:
User
↓
Robot
↓
Action
Now:
Camera
↓
Computer Vision
↓
Detection
↓
Robot Decision
↓
Physical Action
The robot is no longer reacting only to commands.
It can begin reacting to what its sensors see.
📷 The Smart Camera Module
The new Smart Camera layer provides a common interface for robot vision.
The module supports:
- ✅ OpenCV image processing
- ✅ YOLO-based object detection
- ✅ face detection / recognition integration
- ✅ mock mode for development and testing
- ✅ real camera input
- ✅ reusable vision modules for different robots
The objective is to avoid creating a completely different computer-vision implementation for every robot.
Instead, robots can share the same foundation.
Smart Camera
│
┌───────────┼───────────┐
↓ ↓ ↓
Fluffypony Hera Nurse
↓ ↓ ↓
Glass Intruder Patient
Detection Detection Monitoring
This makes the robotics ecosystem easier to extend.
🤖 Fluffypony Smart
One of the first applications is the Fluffypony robot bartender.
The robot can use computer vision to verify whether a glass is present.
A simplified workflow is:
Camera
↓
Frame
↓
Object Detection
↓
"glass" detected
↓
Person detected
↓
Robot continues service
For example, the vision module can produce results such as:
🔍 Checking for glass...
✅ Glass detected
✅ Person detected
🍹 Ready for service
The important part is not the text output.
The important part is that visual information becomes an input to the robot workflow.
Instead of blindly executing:
"Serve drink."
the system can first check:
"Is the required object actually there?"
🛡️ Hera Security Vision
The second major application is Hera Security.
The robot can use its camera to analyze an environment during a patrol.
A simplified workflow:
Camera
↓
Frame
↓
Person Detection
↓
Analysis
↓
Event
↓
Security Workflow
A development test could produce:
🔍 Scanning area...
⚠️ 2 people detected
🚨 EVENT DETECTED
This does not mean the system is already a certified autonomous security product.
It means the computer-vision pipeline can provide information that a future security workflow can use.
Real deployment would require additional testing, privacy safeguards, false-positive handling and human oversight.
🧠 From Detection to Decision
Computer vision by itself is not enough.
The interesting part is connecting detection to robot logic.
For example:
Image
↓
YOLO
↓
Object: glass
↓
Confidence: 0.87
↓
Robot Logic
↓
Continue Workflow
Or:
Image
↓
Detection
↓
Person Found
↓
Robot Logic
↓
Security Event
This creates a new architecture:
Perception → Decision → Action
That is one of the foundations of autonomous robotics.
🛠️ Technical Architecture
The current architecture separates the vision system from the individual robot implementations.
┌──────────────────────────────────────────┐
│ SMART CAMERA │
│ │
│ OpenCV │
│ YOLO │
│ Face Detection / Recognition │
│ Mock Camera │
│ Real Camera │
└───────────────────┬──────────────────────┘
│
▼
┌──────────────────────────────────────────┐
│ ROBOT VISION MODULES │
│ │
│ Fluffypony → Glass Detection │
│ Hera → Person Detection │
│ Nurse → Patient Monitoring │
│ Industrial→ Object Tracking │
│ Educational → Interactive Vision │
└──────────────────────────────────────────┘
The modular design means that improvements to the camera layer can benefit multiple robots.
🐍 Example: Fluffypony Vision
A simplified interface can look like:
from smart_camera import FluffyponyVision
vision = FluffyponyVision()
glass_present = vision.check_glass()
person_present = vision.detect_person()
if glass_present and person_present:
print("Ready for service")
The robot-specific logic stays separate from the underlying computer-vision implementation.
That separation makes the system easier to maintain.
📷 Capturing a Frame
The Smart Camera can operate with a real camera or a mock source.
A simplified workflow:
camera = SmartCamera(use_yolo=True)
camera.start()
frame = camera.capture_frame()
results = camera.process_frame(frame)
The resulting data can contain detected objects and faces.
For example:
for obj in results["objects"]:
print(
f"{obj['class']} "
f"(confidence: {obj['confidence']:.2f})"
)
Example development output:
glass (confidence: 0.87)
person (confidence: 0.92)
These values are examples of the type of information the system can process; actual results depend on the camera, model and environment.
👁️ Why Mock Mode Matters
Real hardware isn't always available during development.
That's why mock mode is important.
Developers can test:
- detection logic;
- robot workflows;
- API integration;
- error handling;
- decision-making;
without needing a physical camera connected.
The development cycle becomes:
Mock Camera
↓
Software Test
↓
Robot Logic
↓
Integration Test
↓
Real Camera
↓
Physical Test
This makes development faster and safer.
📊 Vision Roadmap
Computer vision is being introduced progressively across the ecosystem.
| Sector | Projects | Vision Capability | Status |
|---|---|---|---|
| Fluffypony | 5 | Glass detection | ✅ Implemented |
| Hera | 5 | Person detection | ✅ Implemented |
| Nurse | 5 | Patient monitoring | ⏳ In development |
| Industrial | 4 | Object tracking | ⏳ Planned |
| Educational | 3 | Interactive vision | ⏳ Planned |
The goal is eventually to provide reusable vision infrastructure across the wider robotics ecosystem.
💰 Bounties Behind the Development
The robotics ecosystem is being developed through open-source issues and bounty-driven contributions.
The latest completed work includes:
| Issue | Implementation | Bounty |
|---|---|---|
| #84 | Hardware Integration | 5 XMR |
| #87 | Web Interface | 3 XMR |
| #86 | Sound Effects | 2 XMR |
| #83 | Security Patrol | 3 XMR |
| #66 | Security Robot | 3 XMR |
| #61 | Cleaner | 3 XMR |
| #63 | Scheduler | 1 XMR |
| #62 | Gardener | 2 XMR |
| #89 | Monitor | 4 XMR |
| #64 | Assistant | 4 XMR |
| TOTAL | 35 XMR |
The bounty model connects development work directly to specific GitHub issues.
Issue
↓
CLAIM
↓
Implementation
↓
Pull Request
↓
Review
↓
Merge
↓
XMR Bounty
This allows contributors to work on concrete problems instead of an undefined roadmap.
🧠 EVA + Robot Vision
Computer vision also creates new possibilities for EVA.
EVA is the MyZubster AI agent that provides an operational interface to the ecosystem.
The architecture can evolve toward:
Camera
↓
Vision Module
↓
Detection
↓
Gateway
↓
EVA / AI
↓
Decision
↓
Robot
For example, a future workflow could allow EVA to receive a robot event and summarize it for a human operator.
Instead of manually watching every camera feed, the system could report relevant events.
The AI becomes an interpretation and orchestration layer, while the vision system remains responsible for perception.
🔐 Vision Requires Privacy
Adding cameras also introduces a major responsibility: privacy.
A production system using cameras and face-related technologies would need to consider:
- consent;
- data minimization;
- secure storage;
- access control;
- retention policies;
- encryption;
- false positives;
- local processing where appropriate;
- applicable privacy regulations.
Computer vision should not automatically mean permanent surveillance.
A privacy-focused ecosystem needs to treat visual data carefully.
This is especially important when the system operates around real people.
🪙 Vision + Payments + Robotics
The bigger MyZubster architecture is becoming:
HUMAN
│
▼
EVA
│
┌───────────┼───────────┐
▼ ▼ ▼
Gateway Vision GitHub
│ │
└──────┬────┘
▼
Decision
│
▼
Robot
│
▼
Physical Action
│
▼
Payment
The long-term idea is to connect perception, AI, payments and physical services.
A robot could eventually:
- receive a service request;
- verify payment;
- use sensors to understand its environment;
- make a decision;
- perform a physical action;
- report the result.
That's a much more powerful model than a robot that simply executes predefined commands.
📅 TAZ DAY #1 — Riccione
The next major real-world test is TAZ DAY #1 in Riccione, Italy, planned for September 2026.
The event is designed to bring the MyZubster ecosystem outside the development environment.
Planned demonstrations include:
🤖 Fluffypony Smart
Robot bartender with vision-assisted glass detection.
🛡️ Hera Security Vision
Security robot concept using computer vision.
🧹 Hera Cleaner
Autonomous cleaning concept.
🌱 Hera Gardener
Robot-assisted plant care.
The objective is to test how software, AI, sensors, robotics and people interact in a real physical environment.
🧪 From Simulation to Reality
This is the bigger development loop:
Code
↓
Mock
↓
Unit Test
↓
Integration
↓
Real Camera
↓
Robot
↓
Real Environment
↓
Observation
↓
Issue
↓
Bounty
↓
Fix
↓
Test Again
This is how the ecosystem can evolve.
Every real-world test can reveal new problems.
Every problem can become a GitHub issue.
Every issue can become an open-source contribution.
And every contribution can improve the next physical test.
🌍 What Changes Now?
The biggest change is that robots are moving from:
"robots that execute commands"
toward:
"robots that can perceive their environment before acting."
That difference is fundamental.
A robot with no perception might follow:
COMMAND → ACTION
A robot with vision can follow:
COMMAND
↓
PERCEPTION
↓
CONTEXT
↓
DECISION
↓
ACTION
This is the foundation for more capable autonomous systems.
🚀 What's Next?
The next development steps include:
- expanding vision to more robots;
- improving object detection;
- integrating vision with the Gateway;
- connecting vision events to EVA;
- testing cameras on real hardware;
- improving privacy protections;
- adding more sensor inputs;
- testing robots in real environments.
The ultimate goal isn't simply to give robots cameras.
It is to build a reusable perception layer for the entire MyZubster ecosystem.
Final Thoughts
MyZubster started with robots.
Then came payments.
Then the Gateway.
Then AI.
Now the robots can begin to see.
The architecture is becoming:
👁️ Vision
↓
🧠 AI
↓
⚙️ Gateway
↓
🪙 Payments
↓
🤖 Robotics
↓
🌍 Real World
The Smart Camera is therefore more than another feature.
It is a new sensory layer for the ecosystem.
Fluffypony can begin to understand whether the required object is present.
Hera can analyze its environment.
Future Nurse robots can explore vision-assisted monitoring.
Industrial robots can track objects.
Educational robots can interact visually with their users.
And EVA can eventually help coordinate the information coming from these systems.
We're moving from:
robots that execute
to:
robots that perceive, decide and execute.
The next step is simple:
Put the cameras on real robots.
Take them into the real world.
Test what happens.
Fix what breaks.
Build again.
👁️🤖🧠🌍
Top comments (0)