The owner personalizes
Each person can choose the Skills that make sense for their JrBot. Different units can carry different combinations of capabilities.
JRSKILL NETWORK · JRBOT V1S
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.
THE OPPORTUNITY
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.
Each person can choose the Skills that make sense for their JrBot. Different units can carry different combinations of capabilities.
A Skill developed in China, Brazil or anywhere else can be distributed to compatible JrBots without the creator manufacturing hardware.
Commercial distribution can pay the Skill creator while reserving a share for the platform that organizes discovery, purchase and licensing.
THE CORE IDEA
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.
A developer publishes a Skill compatible with the JrSkill standard without changing the firmware of every individual robot.
Solana is studied as a verifiable infrastructure for Skill, Offer and License state so a wallet purchase can be recognized by any compatible JrBot.
The JrSkill Executor keeps the local boundary: schema, allowlist and Runtime API prevent an external Skill from directly controlling GPIO, drivers or native code.
ARCHITECTURE
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.
LICENSE PATH · VALIDATED
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
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.
{
"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
JrSkill is allowlisted by design. The executor rejects anything outside the supported schema and registered capabilities.
CURRENT CHECKPOINT · OCTOBER 6, 2026
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.
Minimal JSON v1, wait, Recipe resolution and Runtime API execution physically validated.
The original 128-byte Skill was published and independently recovered byte-for-byte from Solana Devnet.
The verified Devnet Skill was executed on the physical robot through the existing executor and Runtime API.
A real Devnet purchase created the License PDA and verified the 50/50 creator/treasury payment split.
A licensed wallet executed successfully; an authenticated wallet without the license was blocked.
The authenticated wallet discovers its licensed Skills from Solana and validates the linked Skill/Offer state.
Over HTTPS, the App authenticates Wallet, confirms Devnet, discovers, selects and executes a licensed Skill with result=ok.
Catalog, Skill details, Wallet, pricing/terms, purchase and License PDA confirmation move to the separate Web product.
LATEST PHYSICAL PROOF
JrBot_V1S_APP_02 · result=ok
HACKATHON TRANSPARENCY
The project keeps a public boundary between the pre-existing physical-AI platform and the Solana/Skill system built during the competition.
ROADMAP
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.
External JSON, wait, Recipes, Runtime API and physical OLED behavior.
Publish and independently retrieve the unchanged JrSkill v1 payload with verified hash and bytes.
Use the Devnet Skill as the source and execute it on the physical robot.
Authenticate Wallet, create/read licenses, complete a real Phantom purchase and verify authorized/blocked execution.
Discover licensed Skills, select one and execute it on the robot from the HTTPS App served by the firmware.
Catalog, Skill detail, Wallet, price/terms, purchase and post-purchase License PDA confirmation in the separate JrBot_Web product.
More Skills, richer capabilities, library versioning, additional commercial models and future Mainnet decisions only after the Store MVP is validated.
BUILD IN PUBLIC
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 →JrSkill Network was registered for the Colosseum hackathon with a deliberately narrow first scope: declarative Skills, no arbitrary downloaded code and safe physical execution.
The V1S line was created from the validated JrBot baseline and the Skill → Executor → Runtime API → hardware boundary was defined.
Minimal JrSkill JSON v1, local wait and Recipe resolution were executed and physically confirmed on the OLED.
The program was deployed and the original 128-byte Skill payload was published and independently recovered with identical bytes and verified hash.
The verified Devnet Skill became the input to the existing executor and produced the expected physical face sequence on the robot.
Wallet authentication, Devnet balance verification and License PDA model-00 were implemented and tested.
A real Phantom purchase finalized on Devnet, creator/treasury payments were verified, unlicensed execution was blocked and licensed physical execution succeeded.
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
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.
FOLLOW THE PROJECT
Current product boundary: the JrBot App is responsible for using licenses already owned by the Wallet. Catalog and purchase now move to the separate JrSkill Store Web.
Follow the Store work