JrBot
PT/EN
Colosseum project
Crypto World’s Fair 2026 Global Skill ecosystem Solana Devnet

JRSKILL NETWORK · JRBOT V1S

A Skill built anywhere. A JrBot able to use it somewhere else.

JrSkill Network researches how JrBot can become a platform expanded through Skills. Owners choose new capabilities for their robot; developers can create and distribute Skills to a global base of compatible JrBots; and Solana is studied as the commercial infrastructure for publishing, licensing and creator payments.

Product vision
Capability-based personalization
Technical checkpoint
Day 7 · licensed flow physically validated
Next layer
JrSkill Store Web
DEVELOPER Creates a JrSkill a portable compatible capability
COMMERCIAL LAYER Solana · Skill · Offer · License publish · verify · license · pay creators
OWNER Store + Wallet + My Skills discover · acquire · select
SAFE PHYSICAL EXECUTION JrSkill Executor · JrBot approved capabilities only
V1S is a parallel proof, not the stable product release. It anticipates the Skill architecture that can later enter JrBot's normal product evolution. Today, the Devnet proof already covers purchase, license, discovery and authorized physical execution.

THE OPPORTUNITY

Every JrBot can gain new capabilities. Every developer can reach compatible robots worldwide.

Because JrBot hardware and firmware are open, the installed base can grow through two paths: official units and robots built by the community itself.

JrSkills add a third force: that base can keep expanding through capabilities created by people and companies anywhere in the world.

01

The owner personalizes

Each person can choose the Skills that make sense for their JrBot. Different units can carry different combinations of capabilities.

02

The developer gets global reach

A Skill developed in China, Brazil or anywhere else can be distributed to compatible JrBots without the creator manufacturing hardware.

03

The platform connects value

Commercial distribution can pay the Skill creator while reserving a share for the platform that organizes discovery, purchase and licensing.

THE CORE IDEA

A common Skill standard creates an ecosystem — not isolated software islands.

A JrSkill describes a capability in a portable form. The commercial layer handles publishing and licensing. JrBot remains responsible for validating and executing only what its hardware can safely support.

{"{}"}

Build once

A developer publishes a Skill compatible with the JrSkill standard without changing the firmware of every individual robot.

◎

Distribute globally

Solana is studied as a verifiable infrastructure for Skill, Offer and License state so a wallet purchase can be recognized by any compatible JrBot.

◇

Execute safely

The JrSkill Executor keeps the local boundary: schema, allowlist and Runtime API prevent an external Skill from directly controlling GPIO, drivers or native code.

Planned network effect More JrBots → more market for Skills → more developers → more Skills → more value for JrBot owners.

ARCHITECTURE

Commerce on the Web. Trust on Solana. Safe execution on the robot.

The product boundary became clearer as the proof evolved: the Store is responsible for discovery and purchase; Solana holds public Skill, Offer and License state; the JrBot App uses licenses already owned by the connected wallet.

01 JrSkill Store catalog · details · Wallet · purchase
02 Solana Devnet Skill PDA · Offer · License PDA
03 JrBot App authenticate · discover licensed Skills · select
04 Skill Executor schema · allowlist · Runtime API
05 Physical JrBot OLED · camera · mic · speaker

LICENSE PATH · VALIDATED

Wallet ownership is now a tested authorization input.

A real licensed wallet was allowed to execute the Devnet Skill on the physical robot, while an authenticated wallet without the license was blocked before command dispatch. The embedded App now performs the licensed usage flow over HTTPS.

Wallet
  ↓ authenticate
License PDA
  ↓
licensed?
  ├─ yes → discover → select → execute
  └─ no  → block Devnet execution

JRSKILL JSON V1

A deliberately small language for the first proof.

The v1 format is frozen for the first blockchain experiment. It contains only a schema version and an ordered list of calls.

Transport details, firmware build IDs, test logs, publisher metadata and license state remain outside the executable payload.

minimal_recipe_01.json
{
  "v": 1,
  "run": [
    ["face", "happy"],
    ["wait", 500],
    ["recipe", "face_sequence"],
    ["face", "neutral"]
  ]
}
face

Translated into the existing Runtime API and executed by the ESP32.

wait

Executed locally by the Skill Executor without sending a hardware command.

recipe

Resolved from a reusable library with recursion protection and depth limits.

SAFETY MODEL

External data never receives direct hardware authority.

JrSkill is allowlisted by design. The executor rejects anything outside the supported schema and registered capabilities.

ALLOWED
  • Known Skill schema
  • Registered functions
  • Validated arguments
  • Bounded Recipe execution
  • Capability discovery
REJECTED
  • Arbitrary native code
  • Shell commands
  • Raw GPIO access
  • Raw memory access
  • Unknown functions

CURRENT CHECKPOINT · OCTOBER 6, 2026

The end-to-end licensed Skill usage flow has reached the JrBot App.

What was previously roadmap is now recorded as Devnet, wallet and physical-hardware evidence through Day 7. The next product line is the separate JrSkill Store Web.

VALIDATED

JrSkill JSON + local executor

Minimal JSON v1, wait, Recipe resolution and Runtime API execution physically validated.

DEVNET

Skill PDA

The original 128-byte Skill was published and independently recovered byte-for-byte from Solana Devnet.

PHYSICAL TEST

Solana → JrBot

The verified Devnet Skill was executed on the physical robot through the existing executor and Runtime API.

REAL PURCHASE

Phantom purchase

A real Devnet purchase created the License PDA and verified the 50/50 creator/treasury payment split.

AUTHORIZED

License gate

A licensed wallet executed successfully; an authenticated wallet without the license was blocked.

DISCOVERY

My Skills

The authenticated wallet discovers its licensed Skills from Solana and validates the linked Skill/Offer state.

DAY 7

Embedded JrBot App

Over HTTPS, the App authenticates Wallet, confirms Devnet, discovers, selects and executes a licensed Skill with result=ok.

NEXT

JrSkill Store Web

Catalog, Skill details, Wallet, pricing/terms, purchase and License PDA confirmation move to the separate Web product.

LATEST PHYSICAL PROOF

The JrBot App now completes the licensed Skill usage flow.

Wallet→Devnet→licensed Skill→select→physical execution
JrBot_V1S_APP_02 · result=ok

HACKATHON TRANSPARENCY

JrBot existed before the hackathon. JrSkill Network is the new work.

The project keeps a public boundary between the pre-existing physical-AI platform and the Solana/Skill system built during the competition.

PRE-EXISTING JRBOT

Physical AI foundation

  • ESP32-S3 robot hardware
  • SSD1306 expressive OLED face
  • OV5640 camera
  • MS3625 microphone + MAX98357A audio
  • Wi-Fi and local HTTPS control
  • Local WebRTC full-duplex audio
  • JPEG video over DataChannel
  • Runtime API baseline
  • Stable product baseline: JrBot_V1.7.04
BUILT DURING THE HACKATHON

JrSkill Network · Day 1 → Day 7

  • V1S experimental line and JrSkill JSON v1
  • Local Skill Executor, wait and reusable Recipe resolver
  • Skill PDA program deployed on Solana Devnet
  • 128-byte Skill published and independently verified
  • Devnet Skill executed on the physical JrBot
  • Wallet authentication and License PDA model-00
  • Real Phantom purchase with verified 50/50 split
  • Licensed/unlicensed execution authorization
  • Wallet Skill discovery
  • Embedded JrBot App with Minhas Skills and physical execution over HTTPS
  • JrSkill Store Web defined as the next separate product layer

ROADMAP

The infrastructure proof is now closed through the robot App.

The next step is no longer “prove Solana”: it is productizing discovery and purchase in the JrSkill Store while preserving the already validated robot-side execution boundary.

  1. 01
    COMPLETED · PHYSICALLY VALIDATED

    Local JrSkill execution

    External JSON, wait, Recipes, Runtime API and physical OLED behavior.

  2. 02
    COMPLETED · DEVNET

    Skill PDA

    Publish and independently retrieve the unchanged JrSkill v1 payload with verified hash and bytes.

  3. 03
    COMPLETED · PHYSICAL TEST

    Solana → Executor → JrBot

    Use the Devnet Skill as the source and execute it on the physical robot.

  4. 04
    COMPLETED · REAL WALLET FLOW

    Wallet + License + purchase

    Authenticate Wallet, create/read licenses, complete a real Phantom purchase and verify authorized/blocked execution.

  5. 05
    COMPLETED · DAY 7

    Embedded JrBot App

    Discover licensed Skills, select one and execute it on the robot from the HTTPS App served by the firmware.

  6. 06
    NEXT PRODUCT LINE

    JrSkill Store Web

    Catalog, Skill detail, Wallet, price/terms, purchase and post-purchase License PDA confirmation in the separate JrBot_Web product.

  7. 07
    LATER

    Expand the Skill ecosystem

    More Skills, richer capabilities, library versioning, additional commercial models and future Mainnet decisions only after the Store MVP is validated.

BUILD IN PUBLIC

Development log.

The public diary now covers the full path from the architecture decision to real purchase, license enforcement and the embedded robot App.

Read the full GitHub devlog →
Kickoff

Project registration and scope

JrSkill Network was registered for the Colosseum hackathon with a deliberately narrow first scope: declarative Skills, no arbitrary downloaded code and safe physical execution.

Day 1

Architecture before blockchain

The V1S line was created from the validated JrBot baseline and the Skill → Executor → Runtime API → hardware boundary was defined.

Day 2

Local Skill physically validated

Minimal JrSkill JSON v1, local wait and Recipe resolution were executed and physically confirmed on the OLED.

Day 3

First JrSkill contract on Solana Devnet

The program was deployed and the original 128-byte Skill payload was published and independently recovered with identical bytes and verified hash.

Day 4

Solana Skill executed on the physical JrBot

The verified Devnet Skill became the input to the existing executor and produced the expected physical face sequence on the robot.

Day 5

Wallet and License PDA model

Wallet authentication, Devnet balance verification and License PDA model-00 were implemented and tested.

Day 6

Purchase, license discovery and authorized execution

A real Phantom purchase finalized on Devnet, creator/treasury payments were verified, unlicensed execution was blocked and licensed physical execution succeeded.

Day 7 · Current checkpoint

The flow moved into the JrBot App

JrBot_V1S_APP_02 was installed and physically validated over HTTPS: Wallet authentication → Devnet verification → licensed Skill discovery → selection → execution → result=ok.

BUILT ON A REAL ROBOT

JrSkill Network is not a simulated robotics concept.

Its first execution target is JrBot, an open-source ESP32-S3 physical AI platform with a camera, microphone, speaker, expressive OLED face, local networking and real-time communication.

The stable JrBot product line remains separate from V1S. The current stable baseline is JrBot_V1.7.04; V1S is an experimental parallel line for the hackathon.

REFERENCE HARDWARE · HW04
Controller
ESP32-S3 N16R8
Camera
OV5640
Display
SSD1306 OLED
Microphone
MS3625 I2S
Audio
MAX98357A
Connectivity
Wi-Fi · HTTPS · WebRTC