DEV Community: Daniel Ioni

From `MODULE_NOT_FOUND` to a Verified AI Token Balance: Debugging MyZubster

Daniel Ioni — Sun, 16 Aug 2026 06:35:02 +0000

From `MODULE_NOT_FOUND` to a Verified AI Token Balance: Debugging MyZubster

A small backend deployment issue turned into a useful debugging session.

While working on MyZubster, my Node.js/Express backend, the application initially failed to load because several route modules referenced by server.js did not exist at the expected paths.

The first error

The first failure was:

Error: Cannot find module './src/routes/geocodeRoutes'

The server contained:

const geocodeRoutes = require('./src/routes/geocodeRoutes');
app.use('/api/geocode', geocodeRoutes);

But the actual route file available in the project was:

src/routes/mapRoutes.js

The route itself was valid and exported an Express router:

const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
  res.json({ message: 'Map routes - placeholder' });
});

module.exports = router;

So the first fix was simply aligning the import with the actual file:

const geocodeRoutes = require('./src/routes/mapRoutes');

The next missing module

After fixing that, Node.js exposed another missing dependency:

Error: Cannot find module './src/routes/healthRoutes'

There was no healthRoutes.js in src/routes.

However, the project already had the health/status endpoints in:

src/api/routes.js

That file contained endpoints such as:

router.get('/health', (req, res) => {
  res.json({
    status: 'ok',
    timestamp: new Date().toISOString(),
    uptime: process.uptime()
  });
});

Instead of creating a duplicate route file, I reused the existing API router:

const healthRoutes = require('./src/api/routes');

and mounted it with:

app.use('/', healthRoutes);

This made the server load successfully:

SERVER LOAD OK
✅ Connected to MongoDB

Verifying the AI forwarding API

The next issue was that the AI balance endpoint initially returned:

{
  "success": true,
  "userId": "DanielIoni-creator",
  "model": "deepseek-chat",
  "totalRemaining": 0,
  "contracts": []
}

That suggested the route was working, but the database query wasn't finding the expected contract.

The controller uses:

const contracts = await AIContract.find({
  userId,
  model,
  status: 'active',
  expiresAt: { $gte: new Date() }
});

The AIContract model stores:

userId: String
model: String
tokens: Number
consumedTokens: Number
status: String
expiresAt: Date

So the next step was to inspect the actual MongoDB data rather than changing the controller blindly.

Finding the real database configuration

The application was using:

mongoose.connect(
  process.env.MONGO_URI || 'mongodb://localhost:27017/myzubster'
);

But .env contained:

MONGODB_URI=...

rather than MONGO_URI.

That explained why standalone diagnostic scripts using:

process.env.MONGO_URI

received:

undefined

The important lesson here was to distinguish between:

the variable name used by the application;
the variable name actually present in .env;
and the environment inherited by PM2.

After aligning the environment configuration, the database could be queried correctly.

The contract was there

The MongoDB inspection showed exactly one AI contract:

userId:          DanielIoni-creator
model:           deepseek-chat
tokens:          1,000,000
consumedTokens:  12,000
remaining:      988,000
status:           active
expiresAt:        2026-11-29T23:00:00.000Z

This was the key verification point.

The data wasn't missing. The API route and controller logic were also correct. The problem was the environment/configuration used during the diagnostic process.

Final production verification

After restarting the PM2 process:

pm2 flush myzubster
pm2 restart myzubster --update-env

the application remained online:

status: online
script path: /root/myzubster/server.js

The health endpoint returned successfully:

{
  "status": "ok",
  "timestamp": "2026-08-16T06:33:25.195Z",
  "uptime": 18.952552298
}

And the AI balance endpoint finally returned:

{
  "success": true,
  "userId": "DanielIoni-creator",
  "model": "deepseek-chat",
  "totalRemaining": 988000,
  "contracts": [
    {
      "id": "6a7fe1a8eba8e2f854ea2eb3",
      "remaining": 988000,
      "expiresAt": "2026-11-29T23:00:00.000Z"
    }
  ]
}

What this debugging session reinforced

A few simple practices made the difference:

Check the filesystem before creating new modules.
A missing geocodeRoutes.js turned out to be an existing mapRoutes.js.
Don't duplicate existing routes.
The health endpoints already existed in src/api/routes.js.
Separate application errors from diagnostic-script errors.
A standalone script failing because MONGO_URI was undefined did not necessarily mean the running application had the same problem.
Inspect the actual database state.
Before changing business logic, verify whether the expected records exist.
Test through the real HTTP endpoint.
The final curl request was the most important verification because it tested the complete chain:

   HTTP → Express → route → controller → Mongoose → MongoDB → JSON response

Final result

The MyZubster backend is now loading correctly under PM2, MongoDB is connected, the health endpoints respond successfully, and the AI forwarding balance endpoint correctly reports:

988,000 remaining tokens.

What initially looked like an application/database problem ultimately came down to a combination of route-path mismatches and environment-variable consistency.

For me, the biggest takeaway is simple: before rewriting logic, verify the filesystem, environment, database, and actual HTTP response one layer at a time.

MyZubster Space Station: from MVP to a Transparent Open-Source Bounty Workflow

Daniel Ioni — Sun, 16 Aug 2026 05:24:03 +0000

MyZubster Space Station: from MVP to a Transparent Open-Source Bounty Workflow

Open-source projects need more than code.

They need a way for contributors to understand what needs to be built, how work is verified, and when a reward has actually been paid.

That's the direction we're taking with the MyZubster Space Station project.

The current project is an experimental software MVP focused on simulation, telemetry, APIs and dashboards. It is not a claim that we have built a physical space station or operational space hardware.

The goal is to build the software foundation first — and make the development process itself as transparent as possible.

What exists today

The Space Station repository currently contains an MVP architecture around:

Space Station Core
robot/mission API
telemetry ingestion
Eva Ioni simulator
web dashboard
Gateway integration
payment integration experiments

The Eva Ioni simulator can generate telemetry such as temperature, humidity and battery information and send it to the telemetry API.

The dashboard can consume telemetry and display it to the user.

The backend provides API endpoints for missions, telemetry and payment records.

These are software prototypes. They should not be confused with production aerospace systems.

From documented bounty to public GitHub issue

One thing we discovered while reviewing the project was that the original documentation listed five bounty items:

Bounty Work Reward

001 Eva Ioni Simulator 250 MYZ

002 Telemetry System 250 MYZ

003 Dashboard UI 250 MYZ

004 Gateway API 250 MYZ

005 MYZ/XMR Payments 250 MYZ

Originally, these were described in the project documentation but were not backed by corresponding GitHub issues in the Space Station repository.

Rather than leaving the bounty system ambiguous, we decided to formalize the work publicly.

The five tasks are now tracked through GitHub issues in the main repository:

390 — Eva Ioni Simulator

391 — Telemetry System

392 — Dashboard UI

393 — Gateway API

394 — Payments

Each issue contains acceptance criteria, scope, verification requirements and the declared bounty.

This gives contributors a much clearer workflow.

The important distinction: merged does not mean paid

We are also introducing a strict distinction between development status and payment status.

A bounty should follow a process like:

AVAILABLE
↓
CLAIMED
↓
IN PROGRESS
↓
PR OPEN
↓
REVIEW
↓
MERGED
↓
PAYMENT PENDING
↓
PAYMENT VERIFIED

A merged pull request is evidence that the software work was accepted.

It is not automatically evidence that the contributor was paid.

For a bounty to be marked as paid, we want a separate, verifiable payment record.

Why this matters

This is especially important for cryptocurrency-related projects.

A statement such as:

"This bounty was paid."

is much less useful than:

Issue: #XXX
Contributor: @username
PR: #YYY
Amount: XXX
Currency: XMR
Network: mainnet
Transaction:
Status: CONFIRMED

The objective is to make the payment independently verifiable whenever the underlying payment system supports it.

MYZ and XMR are not the same thing

Another point we want to make explicit is the distinction between MYZ and XMR.

XMR is Monero.

If MYZ represents a project-specific accounting unit or token, it must not be presented as though it were Monero.

For any future real token/payment implementation, the project should document:

network;
asset/token identifier;
wallet/address format;
transaction mechanism;
transaction explorer;
verification procedure.

Until that information is available, simulated or internal payment records should be labelled accordingly.

What we are looking for

The five current bounty issues are intended to attract contributors who want to improve the software itself.

The most useful contributions are not necessarily large.

A good contribution might be:

improving telemetry validation;
adding tests;
making the simulator configurable;
improving dashboard reliability;
implementing Gateway integration;
improving documentation;
implementing verifiable payment infrastructure.

Every contribution should be reproducible and reviewable.

What "Space Station" means here

The name can easily create the wrong impression, so let's be explicit.

This repository does not represent a deployed space station.

It is an experimental software environment for:

simulation + telemetry + APIs + dashboards + future robotics integration.

The long-term vision may include more advanced robotics and space-related simulations, but those are future engineering goals, not claims about currently operational hardware.

The experiment

The interesting experiment is therefore not:

"Can we claim to have built a space station?"

It is:

Can an open-source community progressively build the software infrastructure through publicly verifiable contributions and rewards?

That's a much more useful question.

The next milestone is simple:

Get an independent contributor to claim one of the bounty issues, submit a PR, have the work reviewed and merged, and then demonstrate the payment process transparently.

If that workflow works, we have something much more valuable than another README claiming that everything is "complete".

We have a reproducible open-source development process.

Follow the work

The project is open source and contributions are welcome.

The five current bounty tasks are tracked publicly in GitHub:

390 — Eva Ioni Simulator

391 — Telemetry System

392 — Dashboard UI

393 — Gateway API

394 — Payments

Status matters. Evidence matters. And a bounty is not considered paid until the payment can actually be verified.

That's the standard we're going to use going forward.

Tag suggeriti su DEV

opensource · javascript · robotics · monero · webdev

MyZubster: An Open-Source Ecosystem Connecting Robotics, IoT, Blockchain and 3D Reconstruction"

Daniel Ioni — Sat, 15 Aug 2026 17:56:33 +0000

🤖 MyZubster: Connecting Robotics, IoT, Blockchain and 3D Reconstruction

What if an open-source project could bring together robots, urban gardens, IoT sensors, privacy-focused payments, cryptography and 3D reconstruction?

That's the idea behind MyZubster.

MyZubster is an open-source ecosystem I'm building around practical hardware and software projects, with the goal of making robotics and automation accessible to makers, developers and contributors.

The project is organized around GitHub repositories, documentation, issues, milestones and a community-driven bounty system.

🌱 What is MyZubster?

The ecosystem currently focuses on several areas:

🤖 Open-source robotics
🚁 Autonomous and experimental drones
🌱 Urban gardening and IoT
🔐 Privacy-oriented blockchain integrations
🧬 Post-quantum cryptography research
📐 3D scanning and reconstruction
🧱 Beginner-friendly construction manuals

The goal isn't to build isolated prototypes.

The goal is to create an ecosystem where these technologies can interact.

🤖 EVA IONI

One of the main projects is EVA IONI, an experimental robot designed around urban gardening and automation.

The concept includes:

environmental sensors
automated irrigation
remote monitoring
cloud connectivity
modular hardware
open documentation

The long-term idea is to make the hardware reproducible rather than keeping the design inside a proprietary platform.

🚁 Urban Lab Drone

Another part of the ecosystem is the Urban Lab Drone.

The project explores how drones can be combined with:

autonomous navigation
environmental mapping
3D reconstruction
telemetry
decentralized payment concepts

The objective is to experiment with real-world applications rather than building another isolated drone prototype.

🌱 IoT Urban Gardens

MyZubster also explores connected urban gardens.

Sensors can monitor parameters such as:

soil moisture
temperature
light
environmental conditions

The collected data can then be used to support automated irrigation and monitoring.

This creates a bridge between physical infrastructure and software automation.

🔐 Monero and MYZ

Privacy is another important part of the project.

MyZubster experiments with Monero (XMR) for privacy-oriented payments and uses MYZ as a project-specific reward mechanism for contributors.

The idea is simple:

Contributions should be measurable, transparent and potentially rewarded.

Possible contributions include:

code
documentation
testing
CAD designs
hardware experiments
technical research

The bounty system is managed through GitHub issues.

🧬 Quantum and Post-Quantum Cryptography

Another research area is cryptography.

The project explores concepts including:

QKD
BB84
post-quantum cryptography
secure wallet architectures

This part of MyZubster is particularly experimental.

The goal is not to claim that quantum technology magically makes a system secure, but to investigate how emerging cryptographic techniques could be integrated into future decentralized systems.

📐 3D Reconstruction

3D reconstruction is another major area of development.

The project investigates automated pipelines for transforming scans and captured data into usable 3D models.

These models could eventually be used for:

robot mapping
drone mapping
garden surveying
CAD workflows
digital twins
autonomous navigation

We are also experimenting with modern 3D scanning hardware, including the Revopoint Trackit SR.

The goal is to connect the scanning process with the rest of the ecosystem instead of treating 3D models as isolated files.

🧱 Documentation Inspired by LEGO Manuals

Hardware projects often fail at one important thing:

documentation.

A technically brilliant robot is difficult to reproduce if nobody can understand how to build it.

That's why MyZubster is developing step-by-step manuals inspired by LEGO-style instructions.

The documentation aims to include:

parts lists
assembly instructions
wiring
software setup
firmware
CAD files
testing procedures

The objective is to make complex projects approachable for beginners while still providing useful information for experienced makers.

🧩 GitHub-Driven Development

The project is organized around GitHub.

Issues are grouped into milestones covering areas such as:

EVA IONI
Urban Lab Drone
Urban Garden IoT
Quantum Wallet
3D Reconstruction
Documentation and Community

This structure makes it possible to track development publicly.

Repository:

MyZubster Manuals

https://github.com/MyZubster-Ecosystem/myzubster-manuals

Organization:

https://github.com/MyZubster-Ecosystem

💰 An Open Contribution Model

One experiment we're running is a GitHub-based bounty system.

Instead of simply saying:

"We need someone to work on this."

an issue can describe:

the technical problem
the expected result
acceptance criteria
the potential MYZ reward

This creates a more structured relationship between contributors and projects.

The long-term goal is to make contributions easier to discover and evaluate.

🌍 Why Open Source?

Robotics becomes much more interesting when hardware, software and documentation are open.

A contributor could improve:

hardware → firmware → software → documentation → testing → 3D models

and the improvements can feed back into the ecosystem.

That's the experiment behind MyZubster.

🚀 What's Next?

Some of the areas I'm currently interested in developing further include:

better robotics documentation
reproducible hardware builds
automated 3D reconstruction pipelines
IoT garden automation
drone mapping
cryptographic experiments
contributor tooling
improved GitHub bounty workflows

There is still a lot to build.

That's exactly why the project is open.

🛠️ Want to Contribute?

You don't need to be a robotics expert.

Contributions can include:

programming
electronics
CAD
documentation
testing
research
translations
technical writing

Start with the GitHub issues:

https://github.com/MyZubster-Ecosystem/myzubster-manuals/issues

Or explore the organization:

https://github.com/MyZubster-Ecosystem

Website:

https://myzubster.com

Final Thoughts

MyZubster is an experiment in combining open-source hardware, robotics, IoT, privacy technologies and community-driven development.

The interesting part isn't any single component.

It's seeing what happens when they are connected.

If you're interested in robotics, open hardware, IoT, 3D reconstruction, cryptography or maker projects, you're welcome to explore the repositories and contribute.

🚀 Build it. Document it. Share it. Improve it.

MyZubster: reorganizing an open-source ecosystem for robots, IoT, drones and quantum technologies

Daniel Ioni — Sat, 15 Aug 2026 17:34:56 +0000

MyZubster: reorganizing an open-source ecosystem for robots, IoT, drones and quantum technologies

MyZubster is growing, and with growth comes a problem every open-source project eventually faces: organization.

We recently reorganized the issue structure of the MyZubster ecosystem to make contributions easier to understand, track and complete.

The goal is simple:

Every issue should belong to a clear project, milestone and contribution path.

🧩 From one milestone to a structured roadmap

Previously, a large number of issues had ended up grouped under the same milestone.

That made it harder to understand what belonged to which project.

We have now reorganized the repository into dedicated milestones:

Milestone Project Issues
2 EVA IONI #1–#8
3 Urban Lab Drone #9–#11
4 Orto Urbano IoT #12–#13
5 Quantum Wallet #14–#15
6 3D Reconstruction #17–#22
7 Documentation & Community #16, #23

This gives us a much clearer roadmap for contributors.

🤖 EVA IONI

The first group focuses on EVA IONI, our robotics and automation direction.

The issues cover the different components needed to develop the project and connect robotics with the wider MyZubster ecosystem.

The objective isn't simply to build a robot.

It's to create an open platform where hardware, software, automation and community contributions can work together.

🚁 Urban Lab Drone

Issues #9–#11 are dedicated to the Urban Lab Drone.

This area explores autonomous aerial systems, mapping and the collection of environmental data.

The long-term vision is to connect drone data with other components of the ecosystem, including robotics, urban agriculture and 3D mapping.

🌱 Urban IoT Garden

Issues #12–#13 cover the Orto Urbano IoT project.

The idea is to combine sensors, automation and open-source software to monitor and manage urban growing environments.

This creates an interesting bridge between:

IoT
robotics
environmental monitoring
automation
open hardware
⚛️ Quantum Wallet

Issues #14–#15 belong to the Quantum Wallet milestone.

This part of the project explores cryptography, wallets and technologies that could become relevant as quantum computing evolves.

The important part here is experimentation and research rather than pretending that every component is already production-ready.

🧊 3D Reconstruction

Issues #17–#22 remain under 3D Reconstruction.

This work is particularly interesting for robotics and autonomous systems.

A robot or drone that can understand its environment needs more than raw sensor data: it needs a representation of the world it is operating in.

3D reconstruction can therefore become a common layer connecting:

drone → sensors → mapping → robotics → environment

📚 Documentation & Community

Finally, issues #16 and #23 are dedicated to documentation and community.

This may sound less exciting than robotics or drones, but it is actually one of the most important parts of an open-source ecosystem.

If nobody can understand how a project works, it cannot scale.

Good documentation is infrastructure.

Why this reorganization matters

The biggest improvement isn't the number of milestones.

It's traceability.

A contributor should be able to go from:

Project → Milestone → Issue → Pull Request → Merge

without having to guess where their work belongs.

This also makes it easier to evaluate contributions and eventually connect completed work with the project's bounty system.

💰 Contributions and bounties

MyZubster uses GitHub issues as the primary starting point for contributions.

A contributor can select an issue, work on it, submit a Pull Request and have the contribution reviewed.

The intended workflow is:

Issue
↓
Contributor
↓
Implementation
↓
Pull Request
↓
Review
↓
Merge
↓
Bounty verification
↓
Payment

This structure allows us to keep technical work and contribution accounting connected.

Of course, a bounty is only considered payable after the relevant contribution has been properly verified and merged according to the project's rules.

Open source is also an experiment in coordination

One of the interesting things about building MyZubster is that the technical architecture isn't the only architecture we need to design.

We also need an architecture for collaboration.

Repositories, issues, labels, milestones, pull requests, documentation and contributors are all part of that system.

That's why we're treating GitHub not just as a place to store code, but as part of the project's operational infrastructure.

What's next?

With the milestones reorganized, the next step is to work through the issues systematically.

The priorities are:

improve documentation;
validate existing issues;
connect issues with concrete implementation tasks;
review incoming pull requests;
verify contributors and completed work;
merge validated contributions;
process eligible bounties.

The objective is to make MyZubster increasingly transparent, reproducible and contributor-friendly.

If you're interested in robotics, drones, IoT, urban agriculture, cryptography, 3D reconstruction or open-source infrastructure, there are several areas where you can participate.

🚀 Join the project

You can explore the repositories and issues here:

MyZubster-Ecosystem on GitHub

The documentation repository:

MyZubster Manuals

And the project website:

MyZubster

Build with us. Document with us. Break things, fix them, and contribute.

opensource #robotics #iot #drones #opensourcehardware #github #automation #cryptography #3d #myzubster

MyZubster: An Open-Source Ecosystem for Robotics, Urban Gardens and Privacy"

Daniel Ioni — Sat, 15 Aug 2026 08:48:28 +0000

🌱 MyZubster: An Open-Source Ecosystem for Robotics, Urban Gardens and Privacy

What if robotics, IoT, open-source hardware and privacy-focused technologies could live in the same ecosystem?

That's the idea behind MyZubster.

MyZubster is an open-source project focused on building a community-driven ecosystem around:

🤖 Open-source robotics
🌱 IoT-powered urban gardens
🔐 Privacy-focused payments with Monero
🪙 MYZ community rewards
🔬 Cryptography research
🧊 3D reconstruction
🧱 Beginner-friendly technical documentation
🏆 Open-source bounty programs

The goal is simple:

Build it. Document it. Test it. Share it.

🤖 1. Open-Source Robotics

One of the main areas of MyZubster is open-source robotics.

Current concepts and projects include:

🌱 EVA IONI

A robot concept designed for urban gardens.

The system can combine sensors for:

Soil moisture
Temperature
Light
Environmental monitoring

The objective is to create an affordable platform that can collect data and automate selected garden tasks.

🚁 Urban Lab Drone

An experimental drone concept connected to the wider Urban Lab ecosystem.

The project explores the integration of autonomous systems, telemetry, payments and community reward mechanisms.

🤖 Urban Robot

A robotics platform for garden and environmental monitoring.

The long-term objective is to create modular hardware that can be adapted to different environments and tasks.

🌱 2. IoT Urban Gardens

Urban agriculture is another important part of the project.

A typical installation can include:


text
Sensors
   │
   ▼
ESP32 / Controller
   │
   ├── Soil moisture
   ├── Temperature
   ├── Light
   └── Other sensors
   │
   ▼
Backend / API
   │
   ▼
Dashboard
This architecture makes it possible to monitor plants remotely and build automated irrigation systems based on sensor data.

The long-term goal is to make these systems:

Affordable
Modular
Repairable
Open-source
Easy to reproduce
🔐 3. Monero and Privacy

MyZubster also explores privacy-focused payment infrastructure using Monero (XMR).

The idea is to allow decentralized projects to experiment with private payments without relying exclusively on traditional payment processors.

Potential applications include:

Robot rentals
Hardware services
Community contributions
Digital services
Open-source project incentives

Payment functionality is developed as part of the broader Urban Lab/MyZubster ecosystem.

🪙 4. MYZ Community Rewards

MyZ is used within the ecosystem as a reward mechanism for community contributions.

Possible contributions include:

💻 Code
📚 Documentation
🧪 Testing
🐛 Bug reports
🔧 Hardware development
📐 CAD designs
🌱 IoT experiments

The idea is to make open-source contribution measurable and incentivized.

For example:

GitHub Issue
     │
     ▼
Contribution
     │
     ▼
Review / Testing
     │
     ▼
Issue completed
     │
     ▼
MYZ reward

This creates a simple feedback loop:

Contribute → Build → Test → Improve → Reward

🏆 5. Open-Source Bounties

MyZubster includes a bounty-oriented approach to community development.

Contributors can browse open issues, select tasks and submit their work through GitHub.

The current bounty program is available here:

👉 https://github.com/DanielIoni-creator/myzubster-manuals/issues

Before starting a bounty, contributors should always verify the current issue description, reward and acceptance criteria.

🔬 6. Cryptography Research

Another experimental area is cryptography.

The project explores concepts including BB84 quantum key distribution (QKD) and post-quantum cryptography.

These technologies should be considered research and experimentation areas, rather than claims that a production-ready quantum-secure payment system has already been achieved.

The objective is to learn how emerging cryptographic technologies could interact with decentralized systems in the future.

🧊 7. 3D Reconstruction

MyZubster also explores automated 3D reconstruction for applications such as:

Urban gardens
Robots
Outdoor environments
Mapping
Hardware development

The idea is to combine cameras, sensors and computational reconstruction techniques to create useful 3D models.

Experimental accuracy should always be evaluated against a defined reference system and documented with reproducible measurements.

🧱 8. Documentation for Everyone

Open-source hardware can be difficult to reproduce.

That's why documentation is a major part of MyZubster.

We're working toward manuals that explain projects step by step using simple diagrams and visual instructions.

Each guide can include:

📋 Bill of Materials
🔧 Required tools
📐 Assembly instructions
💻 Software setup
⚡ Electronics diagrams
🧪 Testing procedures
🛠️ Troubleshooting

The inspiration is simple:

Technical documentation should be understandable even if you're building the project for the first time.

🛠️ Technology Stack

Depending on the project, the ecosystem can involve technologies such as:

Area    Technologies
Microcontrollers    ESP32, Arduino
Computing   Raspberry Pi
Backend Node.js, Express
Database    MongoDB
Robotics    Motors, servos, sensors
IoT MQTT, HTTP APIs
Blockchain  Monero
CAD STEP, STL, F3D
AI  OpenAI / other AI APIs
Version control Git + GitHub

The architecture is intentionally modular so individual components can be replaced or improved without rebuilding the entire system.

📦 Open Source

The project is built around open-source development.

Code, documentation, hardware designs and experiments can be published through GitHub repositories.

Main starting point:

👉 https://github.com/DanielIoni-creator

Manuals and development issues:

👉 https://github.com/DanielIoni-creator/myzubster-manuals

Official website:

👉 https://myzubster.com

🚀 How Can You Contribute?

You don't need to build an entire robot to participate.

You can contribute by:

💻 Developers

Improve APIs, backend services, dashboards or automation.

🔧 Hardware enthusiasts

Design PCBs, enclosures, mechanical components or sensor systems.

📚 Technical writers

Improve manuals and make complex projects easier to reproduce.

🧪 Testers

Build prototypes, report bugs and document results.

🌱 Makers

Experiment with IoT gardens and environmental monitoring.

🤖 Robotics enthusiasts

Develop new modules and robotic applications.

🌍 Why Open Source?

The most interesting part of MyZubster isn't a single robot, token or piece of software.

It's the possibility of combining them into an ecosystem where people can:

Build → Share → Test → Improve → Reuse

Instead of keeping every component inside a proprietary platform, the goal is to make the technology accessible to the community.

🔭 What's Next?

The next steps include improving:

Hardware documentation
Robotics prototypes
IoT garden automation
GitHub bounty workflows
APIs
3D reconstruction experiments
Cryptography research
Community documentation

The project is still evolving, and that is exactly why community contributions are important.

🤝 Join the Project

If you're interested in open-source robotics, IoT, decentralized technologies or maker projects, take a look at the repositories and open issues.

🌐 Website

https://myzubster.com

💻 GitHub

https://github.com/DanielIoni-creator

🏆 Bounties & Documentation

https://github.com/DanielIoni-creator/myzubster-manuals/issues

Final Thoughts

MyZubster is an experiment in combining open-source hardware, robotics, IoT, privacy technologies and community-driven development.

It is not finished.

It's a platform for experimentation, collaboration and continuous improvement.

If you're a developer, maker, researcher or simply curious about building things in the open:

Come build with us. 🚀🌱🤖

Daniel Ioni – MyZubster / Urban Lab

🏭 Urban Lab: Open-Source Mobility, Monero, AI and Community Rewards"

Daniel Ioni — Sat, 15 Aug 2026 04:02:17 +0000

🏭 Urban Lab: Open-Source Mobility, Monero, AI and Community Rewards

Hi everyone! 👋

I'm Daniel Ioni, an independent developer working on Urban Lab, an open-source project exploring how mobility, robotics, privacy-focused payments and AI services can work together.

The goal is simple:

Build open technology that people can inspect, modify, test and improve.

Urban Lab brings together several experimental components:

🛴 Smart electric mobility
🚗 Open-source vehicle concepts
🤖 Robotics projects
🔐 Monero-based payment experiments
💰 MYZ community rewards
🎟️ Coupon and incentive systems
🧠 AI service credits
🛠️ Open-source hardware and software

🌍 The vision

Urban Lab explores a different model for mobility and digital services.

Instead of building a closed platform, the project focuses on open repositories and modular components that developers and makers can experiment with.

The vision is to make it possible to:

Build and modify hardware
Develop new software integrations
Experiment with privacy-preserving payments
Reward useful community contributions
Connect physical devices with digital services
Explore decentralized economic models

This is an open-source experiment, not a finished commercial platform.

🛴 Smart mobility

One part of Urban Lab focuses on smart electric vehicles.

The hardware repository explores components such as:

GPS
ESP32 / Arduino controllers
Battery monitoring
Remote device control
Sensors
Firmware integrations
3D-printable and CAD components

The long-term idea is to connect physical mobility with an open software stack.

Repository:

https://github.com/DanielIoni-creator/urban-lab-hardware

🔐 Exploring Monero for payments

Privacy is an important part of the project.

Urban Lab experiments with Monero (XMR) for payment flows and with a 2-of-3 multisignature escrow architecture.

A simplified escrow workflow looks like this:

Buyer and seller agree on the transaction.
Funds are prepared for the escrow.
Participants exchange/sign the required multisig data.
The required threshold is reached.
The transaction can be released according to the agreed conditions.

The implementation is currently an experimental software project, so production deployments should be independently audited and tested before handling real funds.

Escrow repository:

https://github.com/DanielIoni-creator/I-ECO-01

💰 MYZ community rewards

Another Urban Lab experiment is MYZ, a utility/reward mechanism used inside the project's ecosystem.

The idea is to reward activities such as:

Community contributions
Development work
Testing
Mobility activities
Documentation
Bounties

For example, a future mobility implementation could calculate rewards based on verified distance travelled.

The important distinction is that these are project-specific reward mechanisms, not a claim that MYZ is an established cryptocurrency or guaranteed financial asset.

🎟️ Coupons and incentives

Urban Lab also explores using MYZ as an internal incentive mechanism for coupons.

Possible examples include:

Rental discounts
Service discounts
Community rewards
Promotional credits

A typical API could look like:


bash
POST /api/coupon
and:

POST /api/coupons/redeem

The purpose is to experiment with programmable incentives inside the Urban Lab ecosystem.

🧠 AI Forward

Another experiment is AI Forward.

The concept is simple: users can purchase AI service capacity in advance and potentially receive a discount for committing to future usage.

For example:

Commitment  Experimental discount
1 month 10%
2 months    15%
3 months    20%
6 months    30%

This is inspired by prepaid infrastructure and capacity models.

The system is intended to explore questions such as:

How can AI usage be prepaid?
Can unused capacity be transferred?
Can community credits be used for AI services?
How can developers integrate AI consumption into an open ecosystem?

These percentages are experimental parameters, not guaranteed commercial offers.

🤖 Robotics

Urban Lab also contains several robotics concepts.

Examples include:

MedBot

An experimental healthcare robotics concept focused on monitoring and assistance.

CogniBot

A companion-robot concept designed around interaction and cognitive activities.

EmergiBot

A safety-oriented concept exploring sensors, alerts and location data.

AdminBot

A concept for appointments, reminders and interaction with digital services.

Pytho AI

An AI assistant concept designed to interact with Urban Lab services.

These projects are experimental. Any healthcare or safety-related application would require extensive validation, testing and regulatory compliance before real-world deployment.

🧰 Technology stack

The ecosystem explores a variety of technologies:

Area    Technologies
Backend Node.js, Express, MongoDB
Blockchain  Monero RPC, multisig experiments
Hardware    ESP32, Arduino, Raspberry Pi
Sensors GPS, accelerometers and other modules
Frontend    HTML, JavaScript, React/Vite
AI  API-based AI services
Robotics    Motors, servos and embedded controllers
CAD STL, STEP and 3D-printing workflows

The architecture is modular, so individual components can be developed independently.

📦 Open-source repositories

Some of the main repositories include:

Urban Lab Hardware

https://github.com/DanielIoni-creator/urban-lab-hardware

Hardware and mobility experiments.

Urban Lab Auto

https://github.com/DanielIoni-creator/urban-lab-auto

Open-source vehicle experiments.

Urban Lab Robot

https://github.com/DanielIoni-creator/urban-lab-robot

Robotics projects and prototypes.

Urban Lab Nurse

https://github.com/DanielIoni-creator/urban-lab-nurse

Experimental healthcare robotics concepts.

MyZubster

https://github.com/MyZubster-Ecosystem/myzubster

Backend and ecosystem experiments.

I-ECO-01

https://github.com/DanielIoni-creator/I-ECO-01

Experimental Monero escrow infrastructure.

🧪 Current status

Urban Lab is actively evolving.

Current work includes experiments around:

✅ Open-source hardware
✅ Monero payment integration
✅ Multisig escrow architecture
✅ Community bounty systems
✅ MYZ reward mechanisms
✅ Coupon APIs
✅ AI service-credit concepts
🚧 Robotics prototypes
🚧 Mobility integrations
🚧 Production-grade security and validation

Some components are prototypes or simulations and should not be assumed to be production-ready.

👨‍💻 How developers can contribute

If you're interested in the project, there are several ways to participate:

Code

Improve APIs, backend services, dashboards and integrations.

Hardware

Experiment with CAD designs, electronics and embedded firmware.

Documentation

Improve setup guides, architecture documentation and examples.

Testing

Find bugs, test APIs and report reproducible issues.

Ideas

Propose new ways to connect mobility, robotics, privacy and open-source software.

🚀 Getting started

Clone the hardware repository:

git clone https://github.com/DanielIoni-creator/urban-lab-hardware.git
cd urban-lab-hardware

Then explore the documentation and open issues.

For developers interested in the backend, start by reviewing the MyZubster and I-ECO-01 repositories.

🔐 Why Monero?

Urban Lab is particularly interested in Monero because privacy can be an important property for digital services.

The project explores how private payments could interact with:

Mobility services
Escrow
Digital rewards
Community marketplaces
AI services

The objective isn't simply to add cryptocurrency to a project.

The objective is to investigate what becomes possible when privacy is treated as a fundamental design requirement.

🌱 What's next?

The next phase is about turning individual experiments into better documented and more reproducible projects.

The priorities are:

Improve documentation
Increase automated testing
Improve security
Validate hardware designs
Build better developer APIs
Expand community contributions
Separate experimental components from production-ready components
🤝 Join the project

Urban Lab is open to developers, makers, researchers and privacy enthusiasts.

If you're interested in:

Open source + Monero + AI + robotics + mobility

come and explore the repositories, open an issue or contribute a pull request.

The project is still evolving.

And that's exactly what makes it interesting.

Build openly. Experiment responsibly. Share what you learn. 🚀

Daniel Ioni — Urban Lab

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics, Monero and AI"

Daniel Ioni — Sat, 15 Aug 2026 03:53:19 +0000

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics, Monero and AI

What happens when open-source hardware, robotics, AI and privacy-focused payments are combined into one ecosystem?

This is the idea behind Urban Lab.

Urban Lab is an experimental open-source project exploring:

🛴 Smart electric mobility
🚗 Open vehicle platforms
🤖 Robotics
🧠 AI-powered services
🔐 Monero payment and escrow workflows
💰 Community reward mechanisms
🎟️ Coupon systems
🌍 Open-source collaboration

The project is being developed openly through multiple GitHub repositories.

🌍 The Vision

Our vision is simple:

Technology should be open, inspectable and buildable by the community.

Urban Lab explores a model where people can contribute to hardware, software and infrastructure without depending entirely on closed platforms.

The ecosystem is designed around four main principles:

Build.

Create open hardware and software.

Experiment.

Test new ideas involving mobility, robotics, AI and decentralized infrastructure.

Share.

Publish code, documentation and designs.

Improve.

Allow the community to modify and extend the system.

🛴 Smart Mobility

One of the main Urban Lab projects is an open-source smart scooter platform.

The architecture explores:

GPS tracking
Remote locking
Battery monitoring
ESP32 / Raspberry Pi controllers
Sensor integration
Web APIs
Payment integration

Hardware development:

https://github.com/DanielIoni-creator/urban-lab-hardware

The goal is to make the platform modular enough for developers and makers to experiment with their own implementations.

🚗 Open Vehicle Concepts

Urban Lab is also exploring open-source vehicle concepts.

The idea is to apply the same principles used for the smart scooter:

Open documentation
Modular electronics
Remote telemetry
Software-controlled services
Community development

Repository:

https://github.com/DanielIoni-creator/urban-lab-auto

These projects are experimental and are being developed incrementally.

🔐 Monero Escrow Experiments

Privacy-focused payments are an important part of the Urban Lab architecture.

We are experimenting with Monero-based escrow workflows, including multisignature concepts.

A typical workflow looks like:


text
Create escrow
      ↓
Define buyer + seller
      ↓
Lock / prepare funds
      ↓
Collect required signatures
      ↓
Verify escrow state
      ↓
Release or cancel
The backend exposes APIs for managing the escrow lifecycle.

Example:

curl -X POST http://localhost:5002/api/escrow/create \
  -H "Content-Type: application/json" \
  -d '{
    "serviceId": "URBAN-001",
    "amount": 25,
    "description": "Smart scooter rental"
  }'

Escrow development:

https://github.com/DanielIoni-creator/I-ECO-01

Important: the current implementation should be considered experimental. Testing infrastructure should be used before any real-money deployment.

💰 MYZ Community Rewards

Urban Lab also experiments with an internal reward mechanism called MYZ.

The idea is to reward useful contributions to the ecosystem.

Possible activities include:

Software development
Documentation
Bug reports
Hardware development
Testing
Community contributions
Mobility activities

The exact reward rules, economics and conversion mechanisms are still subject to development and validation.

🎟️ Coupon System

Another experimental component is a coupon system connected to MYZ.

The concept is:

Community contribution
        ↓
      MYZ
        ↓
     Coupon
        ↓
Urban Lab service

Possible applications include discounts for:

Rentals
Repairs
Hardware
Community services

Example API structure:

POST /api/coupons/create
GET  /api/coupons/user/:userId
POST /api/coupons/redeem

This creates a bridge between digital community rewards and real-world services.

🧠 AI Forward

Urban Lab is also experimenting with a concept called AI Forward.

The idea is to allow users to reserve future AI capacity under predefined terms.

For example:

1 month  → 10% discount
2 months → 15% discount
3 months → 20% discount
6 months → 30% discount

A prototype API includes operations such as:

POST /api/ai-forward/quote
POST /api/ai-forward/purchase
GET  /api/ai-forward/user/:userId
POST /api/ai-forward/consume
POST /api/ai-forward/resale

This is an experimental economic model for AI services, not a financial investment product.

🤖 Robotics

Urban Lab also contains several robotics concepts.

Pytho AI

An AI-oriented assistant designed to interact with users and Urban Lab services.

EVA IONI

An experimental platform for urban agriculture and environmental monitoring.

CleanStreetBot

A concept for automated waste detection and collection.

AssemblyBot

An experimental platform for assisting with hardware assembly.

MedBot

A healthcare-assistance research concept.

CogniBot

A companion and interaction robot concept.

EmergiBot

A safety and monitoring concept.

AdminBot

A concept for scheduling, reminders and administrative assistance.

These projects are at different stages of development.

In particular, healthcare and safety-related robots require substantial additional validation, certification and safety testing before real-world deployment.

🛠️ Technology Stack

The ecosystem currently experiments with:

Area    Technologies
Backend Node.js, Express, MongoDB
Blockchain  Monero RPC / multisig experiments
Hardware    ESP32, Raspberry Pi, Arduino
Sensors GPS, accelerometers, environmental sensors
Frontend    HTML, JavaScript, React/Vite
AI  AI APIs
Robotics    Motors, servos and embedded controllers
Development GitHub, REST APIs, Webhooks
📦 Open Source Repositories
Urban Lab

https://github.com/DanielIoni-creator/urban-lab

Hardware

https://github.com/DanielIoni-creator/urban-lab-hardware

Automotive

https://github.com/DanielIoni-creator/urban-lab-auto

Robotics

https://github.com/DanielIoni-creator/urban-lab-robot

Robotics / Assistance

https://github.com/DanielIoni-creator/urban-lab-nurse

MyZubster

https://github.com/MyZubster-Ecosystem/myzubster

I-ECO-01

https://github.com/DanielIoni-creator/I-ECO-01

🧪 Current Status

Urban Lab is an active development project.

Current work includes:

✅ Open-source repositories
✅ Backend APIs
✅ Escrow workflow experiments
✅ Dashboard development
✅ MYZ reward experiments
✅ Coupon API experiments
✅ AI infrastructure experiments
🧪 Robotics prototypes
🧪 Smart mobility hardware
🧪 Continued testing

Some components are prototypes, simulations or development-stage software.

The project should not be interpreted as a production-ready financial, medical, autonomous-driving or safety system.

🚀 What's Next?

The roadmap includes:

Better hardware documentation

More CAD files, BOM information and assembly documentation.

More testing

Continue validating APIs, escrow workflows and hardware components.

Community contributions

Open more issues and development tasks for programmers, makers and researchers.

Robotics

Continue developing experimental robotic platforms.

Mobility

Improve telemetry, hardware integration and smart mobility software.

Privacy

Continue exploring how Monero can be integrated into open-source services.

🤝 Contributing

You don't need to build a robot to contribute.

You can:

🐛 Report bugs
💻 Submit pull requests
🛠️ Improve hardware designs
📖 Write documentation
🧪 Test APIs
🤖 Develop robotics software
🔐 Review security assumptions
💡 Propose new ideas

Start with the GitHub repositories and open an issue.

🏁 Conclusion

Urban Lab is an experiment in combining:

Open hardware + open software + robotics + AI + privacy-focused payments.

The project is still evolving.

That's why the development process is open to contributors.

The long-term vision is a technology ecosystem where people can build their own machines, inspect their software, participate in development and interact through open infrastructure.

Build it.
Inspect it.
Modify it.
Improve it.

Welcome to Urban Lab. 🏭🛴🚗🤖🔐🌍

Daniel Ioni — Urban Lab

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics and Monero Payments"

Daniel Ioni — Sat, 15 Aug 2026 03:37:25 +0000

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics and Monero Payments

What happens when open-source hardware, robotics, privacy-focused payments and community-driven development meet?

This is the idea behind Urban Lab.

Urban Lab is an experimental open-source ecosystem combining:

🛴 Smart electric mobility
🚗 Open-source vehicle concepts
🤖 Service and assistance robots
🔐 Monero-based escrow experiments
💰 MYZ community rewards
🎟️ Digital coupon experiments
🧠 AI-powered services
🌍 Open-source collaboration

The goal is simple:

Build technology that people can inspect, modify, repair and improve.

🌍 The vision

Sustainable mobility and accessible technology should not depend entirely on closed platforms.

Urban Lab explores an alternative model where hardware, software and community infrastructure can be developed openly.

The project aims to make it possible for contributors to:

Build and modify hardware
Develop firmware and software
Experiment with autonomous systems
Use privacy-focused payment infrastructure
Contribute code and documentation
Participate in community reward systems

Urban Lab is currently an open-source development project, with several components still in testing and experimentation.

🛴 Smart Mobility

One of the main Urban Lab projects is an open-source smart scooter concept.

The hardware/software architecture explores:

GPS tracking
ESP32 / Raspberry Pi controllers
Remote locking
Battery monitoring
Sensor integration
Web APIs
Monero payment integration

The hardware repository contains the project's experimental CAD, documentation and development files.

👉 https://github.com/DanielIoni-creator/urban-lab-hardware

The objective is not simply to build another scooter.

It is to create an open platform that developers and makers can modify.

🔐 Exploring Monero Escrow

One of the most interesting parts of Urban Lab is the experimentation with Monero escrow and multisig workflows.

The architecture uses a backend API to manage the lifecycle of an escrow:

Create an escrow
Define buyer and seller
Track the required signatures
Verify the escrow state
Release or cancel the transaction

The current development environment uses testing infrastructure, rather than treating the prototype as a production financial service.

The experimental API includes endpoints such as:


text
POST /api/escrow/create
POST /api/escrow/sign
POST /api/escrow/release
POST /api/escrow/cancel
GET  /api/escrow/status
GET  /api/escrow/list
epository:

👉 https://github.com/DanielIoni-creator/I-ECO-01

The important idea is that payment logic should be auditable and programmable, while private transactions remain possible through Monero.

💰 MYZ Community Rewards

Urban Lab also experiments with an internal reward system called MYZ.

MYZ is designed as a community incentive mechanism for activities such as:

Development
Documentation
Testing
Bug reports
Hardware contributions
Community participation
Mobility-related activities

For example, a future mobility implementation could reward users based on verified activity.

The exact reward rates and conversion mechanisms are still part of the project's development and testing process.

🎟️ Coupon Experiments

Another component of the ecosystem is a coupon system.

The concept is simple:

Community rewards → coupons → services

For example, MYZ could eventually be used to obtain discounts for:

Scooter rentals
Repairs
Hardware
Community services

Example API structure:

POST /api/coupons/create
GET  /api/coupons/user/:userId
POST /api/coupons/redeem

This allows the reward layer to connect with the practical services offered by the ecosystem.

🤖 Robotics

Urban Lab is also exploring several robotics concepts.

🧠 Pytho AI

An AI-oriented assistant designed to interact with users and integrate with Urban Lab services.

🌱 EVA IONI

A concept focused on urban agriculture, sensors and environmental monitoring.

🧹 CleanStreetBot

A robotics concept for detecting and collecting waste in urban environments.

🔧 AssemblyBot

An experimental robotic platform for assisting with hardware assembly.

🩺 MedBot

A concept for healthcare assistance and monitoring.

🧠 CogniBot

A companion-robot concept focused on interaction and cognitive activities.

🚨 EmergiBot

An experimental safety and monitoring robot concept.

📋 AdminBot

A concept for reminders, scheduling and administrative assistance.

These projects are at different stages of development and should be considered experimental prototypes and research concepts, not certified medical or safety products.

🧠 AI + Robotics + Payments

One of the long-term ideas behind Urban Lab is connecting autonomous software agents and robots with economic infrastructure.

Imagine a robot that can:

Receive a task
Estimate the required resources
Complete the task
Report the result
Receive a payment

This creates an interesting question:

Can machines participate in open economic ecosystems without requiring every interaction to be controlled by a centralized platform?

Urban Lab is exploring that question through software, APIs, robotics and privacy-focused payment technology.

🛠️ Technology Stack

The current ecosystem experiments with several technologies:

Area    Technologies
Backend Node.js, Express, MongoDB
Blockchain  Monero RPC, multisig experiments
Hardware    ESP32, Raspberry Pi, Arduino
Sensors GPS, accelerometers and environmental sensors
Frontend    HTML, JavaScript, React/Vite
AI  AI APIs and conversational systems
Robotics    Motors, servos and embedded controllers
Development GitHub, REST APIs, Webhooks

The architecture is intentionally modular so individual components can evolve independently.

📦 Open Source

The project is organized around several repositories.

Urban Lab

👉 https://github.com/DanielIoni-creator/urban-lab

Hardware

👉 https://github.com/DanielIoni-creator/urban-lab-hardware

Automotive experiments

👉 https://github.com/DanielIoni-creator/urban-lab-auto

Robotics

👉 https://github.com/DanielIoni-creator/urban-lab-robot

Robotics / assistance

👉 https://github.com/DanielIoni-creator/urban-lab-nurse

MyZubster

👉 https://github.com/MyZubster-Ecosystem/myzubster

I-ECO-01

👉 https://github.com/DanielIoni-creator/I-ECO-01

🧪 Current Development Status

Urban Lab is an active development project.

Current work includes:

✅ Open-source repositories
✅ Backend APIs
✅ Escrow workflow experiments
✅ Dashboard development
✅ MYZ reward infrastructure
✅ Coupon API experiments
✅ Robotics prototypes
✅ AI integrations
🧪 Continued testing and validation

Some components are prototypes and simulations.

Before using any financial, mobility, medical or autonomous functionality in the real world, additional security, legal, hardware and safety validation is required.

🚀 What's Next?

The next stages of development include:

1. Better hardware documentation

More CAD documentation, BOM improvements and assembly instructions.

2. More testing

Continue testing escrow workflows and backend services in controlled environments.

3. Community development

Open more issues and bounty opportunities for developers, makers and researchers.

4. Robotics

Continue developing the experimental robot platforms.

5. Mobility

Improve the smart scooter architecture and telemetry systems.

6. Privacy-focused payments

Continue researching how Monero can integrate with decentralized services and autonomous systems.

🤝 How You Can Contribute

You don't need to build a robot to contribute.

You can help by:

🐛 Reporting bugs
💻 Opening pull requests
🛠️ Improving hardware designs
📖 Writing documentation
🧪 Testing APIs
🤖 Developing robotics software
🔐 Reviewing security assumptions
💡 Proposing new ideas

Start with the repositories on GitHub.

🏁 Conclusion

Urban Lab is an experiment in combining open-source hardware, robotics, AI and privacy-focused payments into one ecosystem.

The project is still evolving.

That's precisely why we are opening the development process to the community.

The long-term vision is a world where people can build their own machines, inspect their software, contribute to shared infrastructure and interact through open protocols.

Build it. Inspect it. Modify it. Improve it.

Welcome to Urban Lab. 🏭🛴🤖🔐🌍

Daniel Ioni — Urban Lab

# 🌍 Urban Lab: An Open-Source Ecosystem for Mobility, Robots & Monero Payments

Daniel Ioni — Sat, 15 Aug 2026 03:12:57 +0000

After weeks of development, testing and integration, I'm introducing Urban Lab — an open-source project exploring the intersection of smart mobility, robotics, AI and privacy-focused payments.

The project brings together several experimental components:

🛴 Smart electric scooters
🚗 Electric mobility concepts
🤖 Service robotics
🩺 Assistive robotics research
🔐 Monero-based escrow experiments
💰 MYZ community rewards
🧠 AI integrations
🌍 Open-source hardware and software

The idea is simple:

Build mobility and robotics infrastructure that people can understand, modify and contribute to.

🧠 The Vision

Urban Lab explores a model where sustainable mobility and assistive technology can become more open and accessible.

The project aims to make it possible to:

Build open hardware
Modify and repair devices
Develop custom software
Experiment with privacy-focused payments
Contribute code and documentation
Build new robotic applications
Create local Urban Lab communities

This is an ongoing experiment, not a finished commercial platform.

🛴 Smart Scooter

The Urban Lab hardware project explores a smart electric scooter platform with:

GPS
embedded sensors
remote-control capabilities
telemetry
ESP32 / Arduino-based electronics
optional AI integrations
open hardware documentation

Hardware repository:

https://github.com/DanielIoni-creator/urban-lab-hardware

Example development configuration:

Component	Target
Motor	Brushless ~800W
Battery	LiFePO4 48V 20Ah
Target range	~40–60 km
Target speed	~25 km/h
Sensors	GPS, accelerometer, gyroscope

These are development specifications and are not a certification for road use. Any real-world vehicle requires appropriate engineering, safety testing and regulatory compliance.

🚗 Electric Mobility

The same open-source principles can be extended beyond scooters.

The Urban Lab ecosystem also explores an electric vehicle platform:

https://github.com/DanielIoni-creator/urban-lab-auto

The objective is to investigate how open hardware, embedded software and decentralized services could work together across different forms of mobility.

🔐 Monero Escrow

One of the most interesting technical experiments is the integration of Monero-based escrow workflows.

The application architecture uses a 2-of-3 authorization model:


text
              ┌─────────────┐
              │    Buyer    │
              └──────┬──────┘
                     │
                     ▼
              ┌─────────────┐
              │   ESCROW    │
              │    2-of-3   │
              └──────┬──────┘
                     │
           ┌─────────┼─────────┐
           ▼         ▼         ▼
The intended workflow is:

Buyer and seller agree on a service.
An escrow record is created.
Participants authorize the transaction.
The configured threshold is reached.
The release workflow is executed.

The escrow API is being developed in:

https://github.com/DanielIoni-creator/I-ECO-01

For development, testing is performed with simulated data and/or Monero Stagenet where applicable.

⚠️ This is experimental infrastructure. Application-level escrow records should not be confused with confirmed on-chain transactions. Do not use the current system for significant real funds without an independent security review.

💰 MYZ Community Rewards

Urban Lab also experiments with a community reward system called MYZ.

The idea is to create incentives for activities such as:

testing;
development;
documentation;
bug reports;
community participation;
mobility experiments.

A possible reward model could look like:

Activity    Example reward
Scooter trip    0.2 MYZ / km
Vehicle milestone   10–50 MYZ
Bug report  5 MYZ
Documentation contribution  Variable
Development bounty  Variable

These numbers are experimental configuration examples and should not be interpreted as guaranteed financial returns.

🐛 GitHub Bounties

Open-source projects depend on contributors.

Urban Lab is experimenting with GitHub-based bounty workflows where contributors can work on predefined tasks and receive MYZ rewards when contributions are accepted.

Example:

GitHub Issue
     │
     ▼
Contributor
     │
     ▼
Pull Request
     │
     ▼
Code Review
     │
     ▼
Accepted
     │
     ▼
Reward

The backend and community infrastructure are being developed through the MyZubster ecosystem:

https://github.com/MyZubster-Ecosystem/myzubster

🤖 Robotics

Urban Lab also explores several robotic concepts.

🧠 Pytho

An AI-oriented assistant designed to interact with software services and help automate workflows.

Potential applications include:

API interaction
planning
automation
monitoring
user assistance
🌱 EVA IONI

An experimental urban-gardening robotics concept focused on:

environmental monitoring;
soil measurements;
temperature;
humidity;
automation.
🧹 CleanStreetBot

A concept for autonomous or semi-autonomous urban cleaning.

Possible capabilities include:

detecting waste;
collecting waste;
reporting areas requiring cleaning;
telemetry.
🔧 AssemblyBot

An experimental robotic assembly platform designed to investigate automation for hardware production and assembly workflows.

🩺 Assistive Robotics Research

Urban Lab also explores concepts such as:

MedBot
CogniBot
EmergiBot
AdminBot

These projects are research and development concepts, not certified medical devices.

For example, future prototypes could explore:

MedBot

Monitoring non-critical sensor data and assisting with routine workflows.

CogniBot

Conversational interaction and entertainment.

EmergiBot

Detection and notification workflows for predefined events.

AdminBot

Appointments, reminders and administrative assistance.

Any system involving medical care, medication administration, emergency response or patient monitoring would require substantial additional safety engineering, clinical validation, regulatory approval and human oversight before real-world deployment.

🛠️ Technology Stack

The ecosystem currently explores technologies including:

Area    Technologies
Backend Node.js, Express, MongoDB
Blockchain  Monero RPC, multisig experiments
Hardware    ESP32, Raspberry Pi, Arduino
Sensors GPS, accelerometer, environmental sensors
AI  OpenAI API, DeepSeek API
Frontend    HTML, JavaScript, React/Vite
Robotics    Motors, servos, embedded controllers
Development GitHub, REST APIs, WebSockets

The architecture is modular so individual components can evolve independently.

📦 Open Source

The project aims to keep hardware, software and documentation as open as possible.

Main repositories include:

🛴 Urban Lab Hardware

https://github.com/DanielIoni-creator/urban-lab-hardware

🚗 Urban Lab Auto

https://github.com/DanielIoni-creator/urban-lab-auto

🤖 Urban Lab Robotics

https://github.com/DanielIoni-creator/urban-lab-robot

🩺 Urban Lab Nurse Robotics

https://github.com/DanielIoni-creator/urban-lab-nurse

🌐 MyZubster

https://github.com/MyZubster-Ecosystem/myzubster

🔐 I-ECO-01

https://github.com/DanielIoni-creator/I-ECO-01

🧪 Current Status

The project is actively evolving.

Current development areas include:

✅ Open-source repositories
🧪 Monero escrow experiments
🧪 Stagenet testing
🧪 MYZ reward infrastructure
🧪 GitHub bounty automation
🧪 Robotics prototypes
🧪 AI integrations
🚧 Hardware development
🚧 MyZubster integration

Some components are prototypes or simulations rather than production-ready services.

That's intentional.

The goal is to build, test, document and improve each component before considering wider deployment.

📊 Monitoring

Urban Lab also includes development dashboards for monitoring application activity.

Depending on the deployment, dashboards can expose information such as:

escrow status;
pending operations;
completed operations;
simulated transaction volume;
system events;
API activity.

Production deployments would require proper authentication, HTTPS, authorization, monitoring and security controls.

🚀 What's Next?

The roadmap includes:

1. Hardware

Improve mechanical designs, electronics and assembly documentation.

2. Embedded systems

Continue developing GPS, telemetry and connectivity.

3. Monero

Continue testing escrow workflows on Stagenet.

4. Security

Improve authentication, authorization and key-management architecture.

5. Robotics

Build and test additional prototypes.

6. Community

Open more GitHub issues and development bounties.

7. Real-world testing

Move carefully from simulation to controlled real-world testing.

🌍 Why Build in Public?

Because open-source development works best when people can inspect the work.

Instead of saying:

"Trust us."

We want the code, documentation and experiments to be available for people to examine.

You can:

read the code;
open an issue;
suggest an improvement;
submit a pull request;
test the software;
build your own prototype.
🏁 Conclusion

Urban Lab is an experiment at the intersection of:

🛴 Mobility

🤖 Robotics

🧠 AI

🔐 Monero

🔧 Open Hardware

🌐 Open Source

We're still building.

We're still testing.

And we're sharing the process publicly.

If you're interested in open hardware, Monero, robotics, IoT, AI or decentralized infrastructure, check out the repositories and join the development.

Build it. Test it. Improve it.

🛴🌍🤖🔐🚀

Daniel Ioni — Urban Lab

🛴 Urban Lab: Open-Source Smart Scooters, Monero Payments & MYZ Rewards"

Daniel Ioni — Sat, 15 Aug 2026 02:37:02 +0000

🛴 Urban Lab: Open-Source Smart Scooters, Monero Payments & MYZ Rewards

Hi everyone! 👋

I'm Daniel Ioni, an independent developer and founder of Urban Lab.

Today I want to introduce the idea behind Urban Lab: an experimental open-source sustainable mobility ecosystem combining smart electric scooters, privacy-focused payments, AI services and community-driven development.

The project brings together:

🛴 Open-source hardware
🔐 Monero-based escrow experiments
💰 MYZ community rewards
🧠 AI integration
🐛 GitHub bounties
🌍 Open-source community development

The goal is simple:

Make smart mobility easier to build, understand, repair and improve.

🧠 The Vision

Sustainable mobility should not depend entirely on closed hardware and proprietary software.

We want to explore a model where people can:

Build their own smart scooter
Customize the hardware and software
Repair their vehicle
Run their own infrastructure
Use privacy-focused payments
Contribute to the open-source ecosystem
Earn rewards for useful contributions and participation

Urban Lab is an experimental project exploring what a more open mobility ecosystem could look like.

🛠️ 1. Open-Source Hardware

The hardware repository is available here:

https://github.com/DanielIoni-creator/urban-lab-hardware

The repository is intended to contain the building blocks for experimenting with the Urban Lab platform, including:

CAD files
STL / STEP / SCAD models
Bill of Materials
Assembly documentation
Firmware
Electronics documentation
Configuration files

The hardware concept is designed around commonly available components where possible.

A prototype configuration may include:

Component	Target specification
Motor	Brushless ~800W
Battery	LiFePO4 48V 20Ah
Target range	~40–60 km
Target speed	~25 km/h
Sensors	GPS, accelerometer, gyroscope
Controller	ESP32 / compatible MCU

⚠️ These are development targets/specifications for the project and should not be interpreted as certification for road use. Hardware must be independently tested for safety and compliance before real-world deployment.

🔐 2. Monero Escrow

One of the most interesting parts of Urban Lab is the payment architecture.

We are experimenting with a 2-of-3 multisig escrow workflow using Monero.

The basic concept involves three participants:


text
              ┌─────────────┐
              │    BUYER    │
              └──────┬──────┘
                     │
                     ▼
              ┌─────────────┐
              │   ESCROW    │
              │    2-of-3   │
              └──────┬──────┘
                     │
           ┌─────────┼─────────┐
           ▼         ▼         ▼
         BUYER     SELLER     ADMIN

🛴 Urban Lab Goes Open Source: Smart Scooters, Monero Escrow & Open Hardware"

Daniel Ioni — Sat, 15 Aug 2026 02:17:59 +0000

🛴 Urban Lab Goes Open Source: Smart Scooters, Monero Escrow & Open Hardware

What started as an idea for a smart electric scooter is becoming something much bigger.

Urban Lab is going open source.

The project brings together:

🛴 Smart electric scooter hardware
🔧 Open hardware and firmware
🤖 AI-powered services
🔐 Monero-based escrow experiments
🐛 Community development bounties
🌐 Open-source software
📊 Monitoring and automation

The goal is simple:

Build sustainable mobility infrastructure that people can inspect, modify, repair and contribute to.

🌱 Why Open Source?

Modern mobility systems often depend on proprietary hardware and closed software.

That can make it difficult to:

repair a vehicle;
replace components;
understand how the system works;
modify the software;
build alternative applications;
contribute improvements.

We want to experiment with a different approach.

With Urban Lab, the idea is to make as much of the stack as possible accessible to the community.

That includes hardware, firmware, backend services and documentation.

🔧 Open Hardware

The hardware repository is available here:

https://github.com/DanielIoni-creator/urban-lab-hardware

The repository is intended to contain the building blocks required to experiment with the Urban Lab scooter platform.

Depending on the current hardware revision, this includes:

CAD models
3D-printable components
Bill of Materials
electronics documentation
assembly documentation
firmware
configuration files

The project is designed around commonly available components where practical.

The long-term goal is to make the platform easier to reproduce and modify.

⚡ Embedded System

The scooter architecture is designed around a microcontroller such as an ESP32 or compatible hardware.

Potential functionality includes:

GPS positioning
battery monitoring
motor control
connectivity
remote status monitoring
OTA firmware updates
remote locking

A simplified architecture looks like this:


text
                 SMART SCOOTER
                      │
        ┌─────────────┼─────────────┐
        │             │             │
        ▼             ▼             ▼
      GPS          ESP32        Battery
        │             │             │
        └─────────────┼─────────────┘
                      │
                      ▼
                Backend API
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
       Dashboard    AI Agent    Escrow
The hardware is still experimental, so every revision needs to be tested independently before real-world deployment.

🔐 Monero Escrow

One of the most interesting parts of Urban Lab is the payment architecture.

We're experimenting with 2-of-3 multisig escrow workflows using Monero.

The basic model involves three participants:

             ┌─────────────┐
             │    BUYER    │
             └──────┬──────┘
                    │
                    ▼
             ┌─────────────┐
             │   ESCROW    │
             │    2-of-3   │
             └──────┬──────┘
                    │
          ┌─────────┼─────────┐
          ▼         ▼         ▼
        BUYER     SELLER     ADMIN

The idea is that the configured threshold requires two authorized participants rather than allowing a single participant to control the complete workflow.

A typical application flow is:

Customer requests a service.
An escrow record is created.
The participants are identified.
The required authorization/signing workflow takes place.
The configured threshold is reached.
The release workflow is executed.

For development, we're using Monero Stagenet and simulated data.

⚠️ This is an experimental system. Application-level escrow records should not be confused with confirmed blockchain transactions.

🤖 AI and Robot Integration

Urban Lab is also experimenting with software agents.

Current concepts include:

Pytho AI

An AI component that can interact with the Urban Lab infrastructure and assist with planning and automated workflows.

MyZubster Robot

A bot-oriented component for community activity, bounties and rewards.

MIGHTY Planner

A planning assistant for projects and resources.

The interesting part is connecting these systems without giving an AI agent unrestricted control over funds.

For example:

User
 │
 ▼
AI / Robot
 │
 ▼
Urban Lab API
 │
 ▼
Escrow Workflow
 │
 ├── Buyer
 ├── Seller
 └── Admin
 │
 ▼
Monero

The objective is to keep authorization and financial control separated from the autonomous logic.

🐛 Community Bounties

Open source works better when contributors have clear tasks.

That's why we're experimenting with a bounty system.

A GitHub issue can contain a reward such as:

💰 Reward: 20 MYZ

Potential tasks include:

improving documentation;
updating the hardware BOM;
creating assembly guides;
testing firmware;
fixing bugs;
building integrations;
creating tutorials.

The workflow can look like:

GitHub Issue
     │
     ▼
Contributor
     │
     ▼
Pull Request
     │
     ▼
Review
     │
     ▼
Accepted
     │
     ▼
MYZ Reward

The goal is to make contributing to the ecosystem easier and more transparent.

💰 MYZ and XMR

The MyZubster ecosystem also contains experimental accounting and conversion functionality involving MYZ and XMR.

At the current development stage, some conversion examples are simulated.

For example:

{
  "success": true,
  "message": "[SIMULATED] Converted 10 MYZ to 0.01 XMR",
  "txHash": "sim-tx-example"
}

This is important:

A simulated conversion is not a real cryptocurrency transaction.

Before any production conversion or redemption system could be launched, additional work would be required around security, liquidity, custody, pricing and applicable legal requirements.

🌐 MyZubster Integration

Urban Lab is being connected with the broader MyZubster ecosystem.

The architecture currently looks roughly like:

                MyZubsterWeb
                     │
                     ▼
                MyZubster API
                     │
          ┌──────────┴──────────┐
          ▼                     ▼
      Urban Lab             I-ECO-01
          │                     │
          └──────────┬──────────┘
                     ▼
                Escrow Layer
                     │
                     ▼
                   Monero

Potential functionality includes:

scooter listings;
rentals;
service requests;
escrow;
contributor rewards;
GitHub bounties;
notifications;
dashboards.
📊 Monitoring

We also built a monitoring dashboard for the development environment.

It provides visibility into:

escrow records;
pending operations;
completed operations;
simulated volume;
transaction IDs;
current status.

This is particularly useful when testing multiple automated services.

The dashboard is currently intended for development and testing.

A production deployment would require proper authentication, HTTPS, access control and security hardening.

📦 Open Source Repositories
🛴 Urban Lab Hardware

https://github.com/DanielIoni-creator/urban-lab-hardware

💻 Urban Lab Software

https://github.com/DanielIoni-creator/urban-lab

🌐 MyZubster

https://github.com/MyZubster-Ecosystem/myzubster

🔐 I-ECO-01

https://github.com/DanielIoni-creator/I-ECO-01

🌐 MyZubsterWeb

https://github.com/DanielIoni-creator/MyZubsterWeb

🧪 Current Status

The project is currently in active development.

Component   Status
Open-source hardware    🟢 Development
Firmware    🟢 Development
Backend 🟢 Development
Monero escrow   🧪 Experimental
Stagenet testing    🧪 Active
GitHub bounties 🧪 Experimental
AI integrations 🧪 Experimental
MyZubster integration   🚧 Development
Mainnet deployment  ⚪ Not yet launched

We're deliberately testing before putting real funds or production users at risk.

🔐 What Comes Next?

There is still a lot to build.

Our roadmap includes:

1. Hardware

Improve the mechanical design, electronics and documentation.

2. Firmware

Continue testing GPS, connectivity, battery monitoring and OTA functionality.

3. Monero

Expand Stagenet testing and validate the complete wallet/multisig workflow.

4. Security

Add stronger authentication, key management, monitoring and recovery procedures.

5. MyZubster

Connect the frontend, marketplace and contributor systems.

6. Community

Open more development tasks and documentation bounties.

7. Real-World Testing

Only after sufficient hardware and software validation will we consider broader real-world testing.

🌍 Why We're Building in Public

The most interesting part of open source isn't simply publishing code.

It's allowing other people to:

inspect it, question it, improve it and build something unexpected with it.

If the hardware design has a problem, someone can propose a better design.

If the firmware has a bug, someone can submit a patch.

If the escrow architecture has a weakness, someone can point it out.

If someone has a better idea for the mobility platform, they can build it.

That's the experiment.

🏁 Conclusion

Urban Lab is becoming more than a scooter project.

It's an experiment combining:

🛴 Open mobility

🔧 Open hardware

🤖 AI

🔐 Monero

🌐 Open-source software

🐛 Community bounties

We're still testing.

We're still learning.

And we're building the project publicly.

If you're interested in open hardware, Monero, IoT, AI or decentralized infrastructure, we'd love to have you look at the code and tell us what we're doing wrong.

Build it. Test it. Improve it.

🛴🌿🔐🚀

Daniel Ioni — Urban Lab



### Tweet per lanciarlo


> 🛴🔓 **Urban Lab is now open source.**
>
> Smart scooter hardware + firmware + AI + Monero escrow + community bounties.
>
> We're building the mobility stack in public.
>
> Inspect it. Build it. Improve it.
>
> @monero @monerolabs
>
> #Monero #XMR #OpenSource #IoT #Hardware

🏭 Urban Lab: Building a Sustainable Mobility Ecosystem with

Daniel Ioni — Sat, 15 Aug 2026 02:08:10 +0000

🏭 Urban Lab: Building a Sustainable Mobility Ecosystem with

🏭 Urban Lab: Building a Sustainable Mobility Ecosystem with Monero, Multisig Escrow and Automated Bounties

Hi everyone! 👋

I'm Daniel Ioni, an independent developer and founder of Urban Lab, an experimental project combining smart electric scooters, AI-powered services, open-source software and privacy-focused payments.

Over the past few weeks, we've been working on several components of the ecosystem:

🔐 Monero 2-of-3 multisig escrow
🤖 AI and robot integrations
🐛 Automated GitHub bounties
💰 MYZ reward accounting
💱 Experimental MYZ → XMR conversion logic
📊 Real-time monitoring
🌐 MyZubster integration

This article is a technical overview of what we're building, what we've tested and what still needs to be done.

⚠️ Important: The system is still experimental. Testing uses simulated data and/or Monero Stagenet. Any MYZ → XMR conversion examples shown below are application-level simulations unless explicitly stated otherwise. We are not presenting the system as a production financial service.

🛴 The Urban Lab Concept

Urban Lab started with a simple idea:

What if a smart mobility service could combine physical vehicles, AI, open-source software and privacy-focused payments?

The scooter concept includes features such as:

GPS tracking
remote locking
AI integration
digital payments
automated service workflows

But adding a payment system introduces an important question:

How can a customer and service provider reduce the amount of trust required between them?

That's where escrow becomes interesting.

🔐 Monero Multisig Escrow

Our experimental escrow architecture uses a 2-of-3 multisig model.

The three participants can be:

Buyer — the customer
Seller — the service provider
Admin / Arbitrator — an optional third participant

Two authorized participants are required for operations governed by the multisig scheme.

A simplified workflow looks like this:

Customer
   │
   ▼
Create Escrow
   │
   ▼
┌──────────────────────┐
│      2-of-3          │
│   Multisig Escrow    │
├──────────────────────┤
│ Buyer                │
│ Seller               │
│ Admin / Arbitrator   │
└──────────┬───────────┘
           │
           ▼
     Release Workflow
           │
           ▼
         Monero

The application layer tracks the escrow state, while the actual wallet and multisig implementation is responsible for the corresponding Monero transaction workflow.

This distinction is important.

A database record saying:

status = RELEASED

does not by itself prove that a Monero transaction has settled on the network.

⚙️ I-ECO-01

The current escrow backend is I-ECO-01, a Node.js and Express REST API.

The application exposes operations such as:

create
sign
release
cancel
status
list

The backend is responsible for application-level escrow management, including:

unique escrow IDs;
transaction state;
participant information;
authorization tracking;
cancellation;
expiration;
monitoring.

Technology stack

Node.js
Express
MongoDB
Monero Wallet RPC
WebSocket
HTML / JavaScript dashboard

During development, we use Monero Stagenet and simulated application data.

🔄 Example Escrow Workflow

A simplified example:

Step 1 — Create

A customer requests a smart scooter rental.

{
  "service": "Smart Scooter Rental",
  "amount": 25,
  "currency": "XMR"
}

The backend creates a unique escrow ID.

Step 2 — Fund

In a real deployment, the appropriate Monero wallet and multisig workflow would handle the funds.

During development, we distinguish between simulated balances and actual Stagenet transactions.

Step 3 — Authorize

The buyer and service provider participate in the authorization workflow.

Buyer       → authorization
Seller      → authorization
Admin       → optional authorization

Step 4 — Threshold

Once the configured threshold has been reached, the application can update the escrow state.

SIGNED

Step 5 — Release

The release workflow is then executed according to the actual wallet and multisig implementation.

For simulated tests, this can simply update the application state.

For Stagenet testing, the corresponding blockchain transaction can be independently verified.

🐛 Automated GitHub Bounties

Another part of the ecosystem is the experimental GitHub bounty system.

The idea is simple:

A GitHub issue can contain a bounty declaration such as:

💰 Reward: 5 MYZ

When the configured conditions are satisfied, the application can record the reward in the contributor's MYZ balance.

This creates a bridge between:

Open-source contribution → automated reward → ecosystem balance

Example API

Endpoint	Method	Purpose
`/api/bounties`	POST	Create a bounty
`/api/bounties`	GET	List bounties
`/api/bounty-history`	GET	View bounty history
`/api/user-balance/:username`	GET	Check MYZ balance

The system is intended to automate accounting, not to replace GitHub's own security model.

Webhook authentication and authorization are important before exposing this functionality to production users.

💱 MYZ → XMR Conversion

We are also experimenting with a conversion layer between MYZ rewards and XMR-denominated values.

For development purposes, the API can expose functionality such as:

GET  /api/exchange-rate
POST /api/convert-myz-to-xmr
GET  /api/conversion-history

Example:

curl -X POST http://localhost:5003/api/convert-myz-to-xmr \
  -H "Content-Type: application/json" \
  -d '{
    "githubUsername": "DanielIoni-creator",
    "amountMYZ": 10
  }'

A simulated response could look like:

{
  "success": true,
  "message": "[SIMULATED] Converted 10 MYZ to 0.01 XMR",
  "txHash": "sim-tx-1742345678",
  "newBalance": 90
}

The important word here is SIMULATED.

An application-level exchange rate does not automatically create a real market, redeemable asset or blockchain transaction.

Before any real conversion system could be deployed, additional work would be required around custody, liquidity, pricing, security and applicable regulations.

🤖 AI and Robot Integration

Urban Lab is also experimenting with connecting the escrow infrastructure to autonomous software and physical systems.

Current components include:

Pytho AI

AI-based planning and interaction with the escrow infrastructure.

Smart Scooter

A physical mobility service concept with GPS and remote-control functionality.

MyZubster Robot

A bot-oriented component for community, bounty and reward workflows.

MIGHTY Planner

A planning assistant for projects and resources.

The broader architecture looks like:

                CUSTOMER
                    │
                    ▼
              AI / ROBOT
                    │
                    ▼
               ESCROW API
                    │
          ┌─────────┼─────────┐
          ▼         ▼         ▼
        BUYER     SELLER     ADMIN
          │         │         │
          └─────────┼─────────┘
                    ▼
               2-of-3 FLOW
                    │
                    ▼
                  MONERO

We're interested in exploring how autonomous agents can interact with structured payment workflows without giving a software agent unrestricted control over funds.

📊 Monitoring Dashboard

We also built a lightweight dashboard for monitoring the development environment.

It can display:

total escrow operations;
pending transactions;
completed operations;
simulated XMR volume;
escrow IDs;
amounts;
current status.

The dashboard is designed primarily for development and operational monitoring.

A production deployment would require authentication, HTTPS, access control and careful handling of sensitive information.

🌐 MyZubster Integration

Urban Lab is being integrated with the wider MyZubster ecosystem.

The architecture is intended to connect:

MyZubsterWeb
     │
     ▼
MyZubster API
     │
     ▼
I-ECO-01
     │
     ▼
Escrow Layer
     │
     ▼
Monero Wallet

Potential functionality includes:

marketplace listings;
scooter rentals;
repair services;
bounties;
contributor rewards;
escrow creation;
transaction monitoring;
notifications.

📦 Open Source Repositories

The project is being developed openly.

🧪 Current Status

The current development environment includes:

✅ Escrow application layer
✅ 2-of-3 escrow workflow testing
✅ GitHub bounty API
✅ MYZ reward accounting
✅ Experimental MYZ → XMR conversion logic
✅ Monitoring dashboard
✅ Robot / AI integrations
✅ MyZubster integration work
🧪 Monero Stagenet testing
🚧 Production security hardening
🚧 Mainnet preparation

We have also performed more than 25 simulated escrow tests covering creation, authorization, release, cancellation and error handling.

🔐 What Still Needs to Be Done

Before considering real-money production use, we need to address:

secure key management;
wallet isolation;
API authentication;
authorization;
HTTPS;
rate limiting;
audit logging;
multisig recovery;
transaction verification;
dispute resolution;
monitoring;
backups;
security review.

Moving from Stagenet to mainnet is not simply changing an endpoint.

It requires confidence in the complete wallet, transaction, security and operational architecture.

🔜 Roadmap

Our next steps include:

1. Stagenet

Continue testing actual wallet and multisig workflows without exposing real funds.

2. MyZubster Frontend

Make escrow functionality accessible directly from the web interface.

3. Smart Scooter Integration

Connect the software platform with GPS and vehicle-management systems.

4. Mobile Application

Explore a mobile interface for rentals and payments.

5. Reputation System

Build reputation mechanisms for customers, contributors and service providers.

6. Security Review

Review the architecture before considering mainnet.

7. Production

Only after sufficient testing and security validation will we evaluate production deployment.

🙏 How to Contribute

The project is open source and we welcome technical feedback.

You can contribute by:

🐛 Reporting bugs
💻 Opening pull requests
🧪 Testing on Stagenet
📖 Improving documentation
🔍 Reviewing the architecture
💡 Suggesting new integrations

The GitHub repositories are the best place to start.

🏁 Conclusion

Urban Lab started with a simple question:

Can smart mobility services combine AI, open-source software and privacy-focused payments in a practical architecture?

We're experimenting with one possible answer:

🛴 Smart mobility
🤖 AI and autonomous services
🔐 Multisig escrow
💰 Monero
🐛 Open-source bounties
🌐 MyZubster

We're still building.

We're still testing.

And we're deliberately using Stagenet and simulated data before considering real-money production workflows.

That's the point of building in public: share what works, document what doesn't, and let other developers challenge the architecture.

Urban Lab — Mobility, AI, Privacy & Open Source. 🚀🌿🔐

Daniel Ioni — Urban Lab

DEV Community: Daniel Ioni

From `MODULE_NOT_FOUND` to a Verified AI Token Balance: Debugging MyZubster

From MODULE_NOT_FOUND to a Verified AI Token Balance: Debugging MyZubster

The first error

The next missing module

Verifying the AI forwarding API

Finding the real database configuration

The contract was there

Final production verification

What this debugging session reinforced

Final result

MyZubster Space Station: from MVP to a Transparent Open-Source Bounty Workflow

001 Eva Ioni Simulator 250 MYZ

002 Telemetry System 250 MYZ

003 Dashboard UI 250 MYZ

004 Gateway API 250 MYZ

005 MYZ/XMR Payments 250 MYZ

390 — Eva Ioni Simulator

391 — Telemetry System

392 — Dashboard UI

393 — Gateway API

394 — Payments

390 — Eva Ioni Simulator

391 — Telemetry System

392 — Dashboard UI

393 — Gateway API

394 — Payments

MyZubster: An Open-Source Ecosystem Connecting Robotics, IoT, Blockchain and 3D Reconstruction"

🤖 MyZubster: Connecting Robotics, IoT, Blockchain and 3D Reconstruction

🌱 What is MyZubster?

🤖 EVA IONI

🚁 Urban Lab Drone

🌱 IoT Urban Gardens

🔐 Monero and MYZ

🧬 Quantum and Post-Quantum Cryptography

📐 3D Reconstruction

🧱 Documentation Inspired by LEGO Manuals

🧩 GitHub-Driven Development

💰 An Open Contribution Model

🌍 Why Open Source?

🚀 What's Next?

🛠️ Want to Contribute?

Final Thoughts

MyZubster: reorganizing an open-source ecosystem for robots, IoT, drones and quantum technologies

opensource #robotics #iot #drones #opensourcehardware #github #automation #cryptography #3d #myzubster

MyZubster: An Open-Source Ecosystem for Robotics, Urban Gardens and Privacy"

🌱 MyZubster: An Open-Source Ecosystem for Robotics, Urban Gardens and Privacy

🤖 1. Open-Source Robotics

🌱 EVA IONI

🚁 Urban Lab Drone

🤖 Urban Robot

🌱 2. IoT Urban Gardens

🏭 Urban Lab: Open-Source Mobility, Monero, AI and Community Rewards"

🌍 The vision

🛴 Smart mobility

🔐 Exploring Monero for payments

💰 MYZ community rewards

🎟️ Coupons and incentives

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics, Monero and AI"

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics, Monero and AI

🌍 The Vision

🛴 Smart Mobility

🚗 Open Vehicle Concepts

🔐 Monero Escrow Experiments

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics and Monero Payments"

🏭 Urban Lab: An Open-Source Ecosystem for Mobility, Robotics and Monero Payments

🌍 The vision

🛴 Smart Mobility

🔐 Exploring Monero Escrow

# 🌍 Urban Lab: An Open-Source Ecosystem for Mobility, Robots & Monero Payments

🧠 The Vision

🛴 Smart Scooter

🚗 Electric Mobility

🔐 Monero Escrow

🛴 Urban Lab: Open-Source Smart Scooters, Monero Payments & MYZ Rewards"

🛴 Urban Lab: Open-Source Smart Scooters, Monero Payments & MYZ Rewards

🧠 The Vision

🛠️ 1. Open-Source Hardware

🔐 2. Monero Escrow

🛴 Urban Lab Goes Open Source: Smart Scooters, Monero Escrow & Open Hardware"

From `MODULE_NOT_FOUND` to a Verified AI Token Balance: Debugging MyZubster