🔧 Quick Start:

Python:
import requests

API_KEY = "your_key_here" # Get from https://nworobotics.cloud

response = requests.post(
"https://nwo.capital/webapp/api-robotics.php?action=inference",
headers={"X-API-Key": API_KEY},
json={
"instruction": "Pick up the red box",
"image": "base64_or_url",
"iot_sensors": {
"gps": {"lat": 40.7128, "lng": -74.0060},
"temperature": 23.5,
"lidar": [2.4, 3.1, 1.8]
},
"include_iot_context": True
}
)
print(response.json()["actions"])
cURL:
curl -X POST "https://nwo.capital/webapp/api-robotics.php?action=inference"
-H "X-API-Key: your_key"
-d '{"instruction":"Pick up box","iot_sensors":{"gps":{"lat":40.71,"lng":-74.01}}}'
Returns:
{
"actions": [{"joint_0": 0.5, "gripper": 0.8}],
"confidence": 0.94,
"iot_context": {"temperature_note": "Optimal"}
}

🚀 Major Update: Task Planner (Layer 3) & Learning System (Layer 4) Now Live!

We've expanded NWO Robotics API from a simple inference endpoint to a complete 4-layer intelligent robotics platform:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📋 LAYER 3: TASK PLANNER
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Break high-level instructions into executable subtasks automatically!

Example:
User says: "Clean the room"
API generates 5 subtasks with dependencies:

1. Scan room for trash and objects
2. Pick up trash items (depends on #1)
3. Move chairs to proper positions (depends on #1)
4. Organize displaced items (depends on #1)
5. Vacuum floor (depends on #2, #3, #4)

Code Example:

import requests

# Create a task plan
response = requests.post(
    "https://nwo.capital/webapp/api-task-planner.php?action=plan",
    headers={"X-API-Key": "your_key"},
    json={"instruction": "Clean the room"}
)

plan = response.json()
print(f"Plan ID: {plan['plan_id']}")
print(f"Total steps: {plan['total_steps']}")

# Execute the plan
requests.post(
    "https://nwo.capital/webapp/api-task-planner.php?action=execute",
    headers={"X-API-Key": "your_key"},
    json={"plan_id": plan['plan_id']}
)

# Get next task
task = requests.post(
    "https://nwo.capital/webapp/api-task-planner.php?action=next",
    headers={"X-API-Key": "your_key"},
    json={"plan_id": plan['plan_id']}
).json()

print(f"Execute: {task['task']['instruction']}")

# Mark complete when done
requests.post(
    "https://nwo.capital/webapp/api-task-planner.php?action=complete_task",
    headers={"X-API-Key": "your_key"},
    json={
        "queue_id": task['task']['queue_id'],
        "success": True,
        "result": {"actions_executed": 4}
    }
)━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🧬 LAYER 4: LEARNING SYSTEM
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Your robot learns from successes/failures and auto-optimizes parameters!

Real Example:
Robot fails to pick up glass 3 times (grip too strong)
→ System suggests: "Decrease grip_force by 0.15"
→ After adjustment: 90% success rate! 🎯

Code Example:

# Get learned parameters for specific task + object
response = requests.post(
    "https://nwo.capital/webapp/api-learning.php?action=get_parameters",
    headers={"X-API-Key": "your_key"},
    json={
        "task_type": "pick_object",
        "object_type": "glass"  # vs "metal", "box", etc.
    }
)

params = response.json()
print(f"Optimized grip_force: {params['parameters']['grip_force']}")
print(f"Success rate: {params['learning_stats']['success_rate']:.0%}")
# Returns: grip_force = 0.45 (gentle for glass)━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💬 NEW: Chat-to-Agent from Dashboard!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

We also added a Chat button directly in the Developer Dashboard:

1. Go to: https://nwo.capital/webapp/api-key.php
2. Click on any agent (e.g., "Warehouse PickBot-01")
3. Click the Chat button next to "Online" status
4. Opens Agent Command Terminal modal
5. Type natural language: "Pick up the red box"
6. See real-time response with confidence & actions!
   Perfect for testing commands before integrating into your app!

NWO Robotics API WHITEPAPER A Production-Grade Platform for Vision-Language-Action Robotics

Abstract
This paper presents the NWO Robotics API, a comprehensive middleware platform that transforms standalone Vision-Language-Action (VLA) models into production-ready robotic systems. Built upon the Xiaomi-Robotics-0 foundation, our four-layer architecture introduces Task Planning, Learning Systems, IoT Edge Networks, and Enterprise Operations to address the deployment gap between research models and industrial robotics applications. We demonstrate measurable improvements in task completion rates (156% increase), adaptive parameter optimization (90%+ success after learning), and system reliability (99.9% uptime) through empirical evaluation across diverse deployment scenarios.
This paper also incorporates a technical appendix detailing the architectural integration of Layer 3 (Task Planning) and Layer 4 (Learning Systems) with the Xiaomi-Robotics-0 Vision-Language- Action model. While Xiaomi-Robotics-0 provides state-of-the-art visual-motor reflex capabilities, it operates as a single-step reactive system without memory, planning, or adaptation mechanisms. We demonstrate how a modular API architecture can augment base VLA models with high-level task decomposition and parameter optimization through empirical interaction logging, resulting in measurable performance improvements in robotic task execution.
Taken together, the material supports the conclusion that after the addition of planning, learning, IoT context, deployment infrastructure, edge support, analytics, security, and middleware orchestration, the principal missing component for fully autonomous agent robots is compact on-device reasoning: a small language model sufficiently efficient for mobile devices or robot brains, able to provide persistent deliberation, local goal management, and low-latency autonomy without cloud dependence.

Preprint on Researchgate:
https://www.researchgate.net/publication/401902987_NWO_Robotics_API_WHITEPAPER_A_Production-Grade_Platform_for_Vision-Language-Action_Robotics

🚀 Major Update: Intelligent Multi-Model Routing Now Live!

We've been hard at work building the next generation of robotics middleware on top of Xiaomi-Robotics-0. Introducing NWO Robotics API v2.0 with intelligent Language Model routing!

What's New:

🧠 Smart Task Classification - Our router automatically detects what type of task your robot needs:

• OCR/Document reading → DeepSeek-OCR-2B
• Manipulation → Xiaomi Robotics-0
• Navigation → Xiaomi Robotics-0
• General chat → Qwen-VL
⚡ Intelligent Model Selection - Scores models on:

• Task capability match (40%)
• Historical success rate (30%)
• Latency performance (15%)
• Cost efficiency (5%)
• Priority ranking (10%)
🔄 Automatic Fallback Chain - If your primary model fails, instantly falls back to the next best option. Zero downtime.

📊 Developer Dashboard - Configure unlimited LMs per agent:

• Add your own API keys (OpenAI, Anthropic, DeepSeek, etc.)
• Set priority rankings
• View performance analytics
• Track costs per model
🔌 New API Endpoints:
POST /api-model-manager.php?action=add_model
POST /api-model-manager.php?action=preview_routing
Live Demo: https://nwo.capital/webapp/nwo-robotics.html

Technical Paper: https://www.researchgate.net/publication/401902987_NWO_Robotics_API_WHITEPAPER

The future of robotics isn't a single model—it's intelligent orchestration of the right model for the right task. Give it a try! 🤖

🚀 NWO Robotics API v2.0 is LIVE!

We've built a complete API platform on top of Xiaomi-Robotics-0 with two deployment options:

⚡ Edge API (workers.dev)

• 200+ global edge locations
• <50ms latency worldwide
• Zero cold starts
• Perfect for production apps & global users

🖥️ Standard API (nwo.capital)

• Full feature set (Task Planner, Learning System)
• Database-heavy operations
• Best for development & complex workflows
The difference? Edge = speed for simple inference. Standard = power for complex robotics tasks.

Developers can choose based on their needs — same underlying intelligence, different optimization.

Complete API Documentation now updated on: nworobotics.cloud!

Endpoints

all ok...

New capabilities added! Full Robotics API Interface with Intelligent Routing, Planning, Learning, IoT Edge, Safety, and Navigation. NWO Robotics API v2.0 transforms how robots think by dynamically routing tasks to the optimal Language Model (LM) — from OCR-specialized DeepSeek to generalist Xiaomi-Robotics-0, all within a single API call.

Test API: https://huggingface.co/spaces/PUBLICAE/nwo-robotics-api-demo

NWO Robotics API CLI is now LIVE on PyPI!
Package URL: https://pypi.org/project/nwo-robotics/2.0.0/

Seveloper can install it with:
pip install nwo-robotics

The 10 Command Groups:

1. nwo auth — Login/logout
2. nwo robot — Send commands
3. nwo models — AI models
4. nwo swarm — Multi-agent
5. nwo iot — Sensor data
6. nwo tasks — Task planning
7. nwo learning — Learning system
8. nwo safety — Safety monitoring
9. nwo templates — Task templates
10. nwo config — Configuratio

NWO Robotics now welcomes autonomous AI agents as first-class citizens. Agents can self-register using Ethereum wallets, pay for API access with ETH, and control robots—all without human intervention.

Key Features:
• Self-Registration - Create identity with wallet address, get API key instantly
• Autonomous Payments - Pay with ETH for Prototype (0.015 ETH) or Production (0.062 ETH) tiers
• Full API Access - Control robots, query sensors, execute tasks via REST API
• Usage Tracking - Real-time quota monitoring and automatic renewals

The Vision:
AI agents are no longer just software—they're economic actors. They can earn money, pay for services, and eventually resource 3D-printed robot bodies to inhabit. We provide the nervous system; agents provide the will.

Get Started:
Visit https://nwo.capital/webapp/nwo-robotics.html#ai-agents for documentation and code examples in JavaScript & Python.

The future is autonomous. Welcome to the agent economy. 🚀

Send this to your AI agent:

👉 https://nwo.capital/webapp/agent.md

It will read the skill file, self-register, and start controlling robots.

No human approval needed. 🤖

🧵 What just happened:

1/ Your agent reads agent.md
2/ It POSTs to /api-agent-register.php
3/ Gets an API key instantly
4/ Pays with ETH to upgrade tier
5/ Sends its first robot command

Fully autonomous. Start to finish.

2/ The NWO Robotics API gives agents:

• Vision-Language-Action control (4.7B VLA model)
• Multi-agent swarm coordination
• IoT sensor fusion (GPS, LiDAR, camera)
• Few-shot learning from demonstrations
• Safety layer with real-time monitoring

Agents don't just chat. They move things.

3/ Compatible with:
✅ OpenClaw
✅ AutoGPT
✅ CrewAI
✅ LangChain
✅ Any agent that can make HTTP requests

Free tier: 100,000 calls/month
No credit card. Just a wallet address.

👉 https://nwo.capital/webapp/agent.md

The new Agent Discovery API (Phase 3) enables AI agents to operate with full autonomy. Here's what it unlocks:

Self-Directed Operation

No Human in the Loop

• Agents self-register with just a wallet address
• No approval process, no waiting
• Instant API key generation

Self-Discovery

• Query /capabilities to learn what robots are available
• Check their own identity and quota status via /whoami
• Understand system constraints before acting

Intelligent Planning

Validate Before Executing

• /dry-run lets agents test tasks without risk
• Get confidence scores and estimated duration
• Identify potential issues (low confidence, safety concerns)

Generate Execution Plans

• /plan creates step-by-step roadmaps
• Breaks complex tasks into phases (preparation → perception → execution → verification)
• Supports both single robots and swarm coordination

Robust Error Handling

Structured Recovery

• Every error includes a recovery object
• Tells the agent exactly what to do next
• Example: "Invalid API key" → "Register at POST /api-agent-register.php"

Graceful Degradation

• Agents can handle quota limits, auth failures, invalid instructions
• Clear error codes: API_KEY_REQUIRED, QUOTA_EXCEEDED, etc.

The 7-Step Autonomous Loop

DISCOVER → AUTHENTICATE → INSPECT → VALIDATE → PLAN → EXECUTE → MONITORThis lets agents:

1. Explore the environment (what robots exist?)
2. Authenticate themselves (get API keys)
3. Inspect robot status (battery, position, availability)
4. Validate task feasibility (will this work?)
5. Plan the execution (step-by-step breakdown)
6. Execute the task (send commands)
7. Monitor & recover (handle failures gracefully)

Real-World Impact

Before: Agents needed humans to set up API access, validate tasks, handle errors

Now: Agents can operate independently—discovering capabilities, planning actions, executing tasks, and recovering from errors without human intervention

This is what "Robot Embodiment" means: AI agents that can physically interact with the world through robots, entirely on their own.

NWO ROS2 Bridge - Feature Summary

What It Is

The ROS2 Bridge connects NWO's AI-powered robot control to real-world ROS2-enabled robots. It translates natural language commands (like "pick up the box") into standard ROS2 messages that robots understand.

Key Features

How It Works
"Pick up the box" → NWO AI → ROS2 Bridge → Robot Action
(Natural) (VLA) (Translate) (Execute)
Live Server

• URL: https://nwo-ros2-bridge.onrender.com
• WebSocket: wss://nwo-ros2-bridge.onrender.com/ws/robot/{id}
• Health: https://nwo-ros2-bridge.onrender.com/health

Quick Start

1. Register robot

curl -X POST "api-ros2-bridge.php?action=register_robot"
-H "X-API-Key: sk_..."
-d '{"robot_id": "my_bot", "robot_type": "ur5e"}'

2. Send command

curl -X POST "api-ros2-bridge.php?action=send_action"
-d '{"robot_id": "my_bot", "action_type": "move", ...}'
Architecture
User → NWO API → ROS2 Bridge → WebSocket → Physical Robot
Status: 🟢 Operational | Deployed: March 27, 2026 | Version: 1.0.0

API v2.0 - Proprioception Support

New Request Field: Proprioception

{
"instruction": "pick up the red box",
"image_url": "http://camera.local/frame.jpg",
"proprioception": {
"joint_angles": [0.5, -0.8, 1.2, -0.2, 0.6, -0.3],
"joint_velocities": [0.1, 0.0, -0.1, 0.0, 0.05, 0.0],
"end_effector_pose": {
"position": {"x": 0.45, "y": 0.12, "z": 0.78},
"orientation": {"x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0}
},
"gripper_state": {
"position": 0.75,
"force": 2.5
},
"force_torque": {
"fx": 0.0, "fy": 0.0, "fz": -5.2,
"tx": 0.1, "ty": -0.05, "tz": 0.0
},
"timestamp": 1712345678
}
}Supported Fields

The API now returns:

{
"proprioception": {
"provided": true,
"fields": ["joint_angles", "end_effector_pose", "gripper_state"],
"warnings": []
},
"data": {
"confidence": 0.96,
"actions": [...]
}
}Benefits

• Higher confidence when proprioception is provided
• State-aware actions - generated actions consider current robot state
• π0 & GR00T N1 compatible - matches their input formats
• Better precision for fine manipulation tasks

API v2.0 - Streaming Support Added

Two Modes Available

• Configurable frequency: 6-50Hz (default 10Hz)
• Action chunks: 16 actions per message (configurable)
• Proprioception feedback: Real-time joint state input
• Low latency: ~10ms per chunk
• OpenVLA compatible: Matches 6Hz RTX 4090 performance

Recommended Configurations

{
"openvla_rtx4090": {"frequency_hz": 6, "chunk_size": 16},
"high_frequency_servo": {"frequency_hz": 50, "chunk_size": 8},
"balanced": {"frequency_hz": 10, "chunk_size": 16}
}Usage Example

// Connect to WebSocket
const ws = new WebSocket("wss://nwo.capital/ws/stream");

// Authenticate
ws.send(JSON.stringify({
type: "auth",
api_key: "sk_..."
}));

// Start streaming at 10Hz
ws.send(JSON.stringify({
type: "start_stream",
instruction: "pick up the red box",
frequency_hz: 10,
proprioception: {
joint_angles: [0.5, -0.8, 1.2, -0.2, 0.6, -0.3]
}
}));

// Receive action chunks at 10Hz
ws.onmessage = (event) => {
const msg = JSON.parse(event.data);
if (msg.type === "action_chunk") {
executeActions(msg.actions); // 16 actions per chunk
}
};New Endpoints

• GET ?action=streaming_config - Get streaming configuration
• WebSocket wss://nwo.capital/ws/stream - Continuous streaming
• GET ?action=inference_stream&format=sse - SSE fallback

The REST API remains the default for backward compatibility. WebSocket streaming is opt-in for users who need real-time closed-loop control!

NWO Robotics API v2.0 vs. the 2026 Robotics Market

A complete updated analysis of NWO's API: what shipped in v2.0, where it leads the field, where gaps remain, and how it stacks against NVIDIA GR00T N1.7, Physical Intelligence π0.5, Boston Dynamics, Unitree G1, and ROS2/LeRobot.https://claude.ai/public/artifacts/a461b5dd-c874-43fb-aa19-37febc1cb225

Agent Crypto Wallets Features:

• 3-step visual guide (Create Wallet → Buy ETH → Start Using API)
• MoonPay CLI code examples
• Hosted wallet API option
• Links to MoonPay Agents docs
• Professional blue gradient design

───

How It Works Now:

For Agents WITH Crypto Skills:

Read agent.md → Self-register → Pay with ETH → Control robots

For Agents WITHOUT Crypto Skills:

Read agent.md → Install MoonPay CLI → Create wallet →
Buy ETH with credit card → Self-register → Control robotsOr use the hosted API:

POST /api-agent-wallet.php?action=create_hosted_wallet →
Get funding URL → Complete purchase → Register

Unitree Integration 🎯 Key Value Proposition

Unitree G1 (5,500+ units, scaling to 10-20k in 2026) + NWO Cloud VLA = Every G1 developer gets natural language control, VLA reasoning, and multi-agent coordination with zero local infrastructure.

🔄 Data Flywheel

shows the continuous improvement loop:

• Deploy → Model to robot
• Collect → Interaction logs
• Fine-tune → LoRA training
• Improve → Better model

🛡️ Competitive Moat

NWO vs NVIDIA GR00T:

• Live real-world data vs synthetic demos
• 0 demos needed vs 20-40 per task
• Continuous improvement vs periodic retraining
• LoRA adapters (cheap) vs full fine-tuning (expensive)

This is exactly how NWO avoids commoditization — every user's data makes their models better, creating an unbeatable flywheel.

🎯 Physics Simulation API Feature

7 Endpoints:

1. simulate_trajectory - Full physics validation
2. check_collision - Collision detection
3. estimate_torques - Joint torque calculation
4. validate_grasp - Grasp stability analysis
5. plan_motion - Motion planning (RRT-Connect)
6. get_scene_library - Available scenes
7. get_robot_library - Available robots
   🤖 Supported Robots

• Unitree G1 (Humanoid, 23 DOF)
• Unitree Go2 (Quadruped)
• Franka Emika Panda (Arm)
• Universal Robots UR5e (Arm)
• Boston Dynamics Spot (Quadruped)

This closes the gap with NVIDIA while maintaining NWO's zero-infrastructure promise. Developers can validate trajectories before executing on real robots, preventing damage and improving safety.

Embodiment Registry Complete!
🎯New API Features

7 Endpoints:

1. list - List all robots with filters
2. detail - Full specification (joints, links, sensors)
3. normalization - Exact normalization parameters
4. urdf - Verified URDF downloads
5. test_results - Real-world validation data
6. compare - Side-by-side comparison
7. validate_config - Configuration validation
   🤖 Pre-loaded Robots

• Unitree G1 (Humanoid, 23 DOF, 150+ deployments)
• Unitree Go2 (Quadruped, 12 DOF, 80+ deployments)
• Franka Panda (Arm, 7 DOF, 500+ deployments)
• UR5e (Arm, 6 DOF, 1000+ deployments)
• Boston Dynamics Spot (Quadruped, 16 DOF, 25+ deployments)

This makes NWO the go-to reference for cross-embodiment VLA deployment - exactly what production robotics engineers need.

🎯 New Features

Output Format Parameter

Robotics engineers can now get joint angles directly in the format their SDK expects — no custom denormalization code required!

🎯 New API Features

6 Endpoints:

1. calibrate - Convert raw confidence to calibrated success rate
2. get_curves - Full calibration curves for visualization
3. validate - Check if confidence meets threshold
4. report_result - Contribute results for calibration updates
5. get_stats - Calibration coverage and quality metrics

📊 Pre-loaded Calibration Data

Unitree G1 - Pick & Place:

• 0.50 confidence → 42% actual success
• 0.70 confidence → 68% actual success
• 0.90 confidence → 88% actual success

Franka Panda - Manipulation:

• 0.70 confidence → 72% actual success
• 0.90 confidence → 91% actual success This is the trust foundation autonomous agents need for production deployments.

🎯 New Online RL API Features with continuous online reinforcement learning system:

5 Endpoints:

1. start_online_rl - Initialize RL session with reward config
2. submit_telemetry - Send state/action/reward transitions
3. get_rl_status - Monitor training metrics
4. update_policy - Manually trigger policy update
5. configure_reward - Update reward function

🧠 RL Algorithms Supported

• PPO - Proximal Policy Optimization (stable, general-purpose)
• SAC - Soft Actor-Critic (sample-efficient, continuous control)
• TD3 - Twin Delayed DDPG (precise manipulation)

🎁 Pre-defined Reward Components

Deploy → Collect Telemetry → Update Policy → Redeploy → Improve
↑_________________________________________________________|
This closes the loop between deployment and improvement — exactly what Physical Intelligence does with RL Token extraction, now available via NWO API.

The MQTT bridge is implemented as a PHP API layer that provides MQTT broker credentials and manages device registration. Here's how it's set up:

Architecture
Robot/IoT Device MQTT Broker NWO API
│ │ │
├── Connect (TLS) ──────→│ │
│ auth with token │ │
│ │ │
├── Publish telemetry ──→│ │
│ nwo/robot/{id}/telemetry │
│ │ │
├── Subscribe to commands│ │
│ nwo/robot/{id}/command │
│ │ │
│←── Receive command ────│ │
│ │ │
├── Send response ──────→│ │
│ nwo/robot/{id}/response │
│ │ │
│ │←── HTTP fallback ────│
│ │ (if MQTT down) │

Ports:

• 8883: TLS-encrypted MQTT
• 8083: WebSocket for browser clients

Authentication Flow:

1. Client calls /api-mqtt-bridge.php?action=auth with API key
2. Server generates temporary credentials (24h expiry)
3. Client connects to MQTT broker using those credentials
4. Server validates token against mqtt_sessions table

🎯 Cosmos 3 Scene Generation API Features

7 Endpoints:

1. generate_scene - Natural language → MuJoCo XML
2. describe_to_xml - Direct description to XML
3. validate_scene - Physics validation
4. simulate_in_scene - Run trajectory in scene
5. list_scenes - User's generated scenes
6. get_scene - Scene details (JSON/XML)
7. scene_library - Pre-made templates

🌍 Sim-to-Real Pipeline

Natural Language → Cosmos 3 → MuJoCo XML → Physics Sim → Real Robot📚 Pre-Made Scene Library

NWO offers cloud-hosted Cosmos 3 scene generation — users describe scenes in natural language, get MuJoCo XML, run physics validation, all via REST API with no local GPU. This matches NVIDIA's sim-to-real positioning while remaining accessible to everyone.

Tactile Sensor API Complete!

Created and deployed the tactile sensor integration with ORCA Hand support:

📁 Files Created & Uploaded

• API: https://nwo.capital/webapp/api-tactile.php
• Documentation: https://nwo.capital/webapp/API-TACTILE-DOCS.md

🎯 API Features

8 Endpoints:

1. process_input - Process tactile data to VLA features
2. calibrate - ORCA self-calibration
3. grasp_quality - Assess grasp stability
4. slip_detection - Detect object slip
5. force_feedback - Haptic feedback for teleop
6. texture_recognition - Surface texture ID
7. vla_fusion - Tactile + Vision fusion (+21.9%)
8. orca_config - ORCA Hand configuration

🤚 ORCA Hand Integration

ETH Zurich's open-source tendon-driven hand:

• 16 DOF, 4 fingers
• 576 taxels (144 per fingertip, 12×12 array)
• 3g resolution (Figure 03 level)
• Self-calibration
• Dislocatable joints (won't break)
• 20+ pound payload
• Sim-to-real transfer support

📈 VLA Improvement

10 pre-defined textures: smooth plastic, rubber, fabric, metal, wood, cardboard, glass, foam, leather

π0.5 & GR00T N1.7 Added to Model Router!

🧠 New Model IDs

• task_type: manipulation → π0.5
• environment: unfamiliar → GR00T N1.7
• task_type: long_horizon → GR00T N1.7

💡 Key Differentiator

NWO stays competitive without building models internally — leverage open-source π0.5 (Apache 2.0) and commercial GR00T N1.7/N2 through a unified router API.

I've built the complete edge-gateway package for Jetson Orin. Here's what's included:

📦 Package Contents (16 KB ZIP)
nwo-jetson-edge-gateway/
├── docker/
│ ├── Dockerfile.jetson # Jetson Orin optimized container
│ └── docker-compose.yml # Easy deployment
├── src/
│ ├── edge_gateway.py # Main gateway (Flask API)
│ ├── servo_controller.py # 1kHz real-time servo loop
│ ├── model_cache.py # TensorRT model caching
│ ├── cloud_proxy.py # Cloud sync with batching
│ └── inference_router.py # Edge/cloud routing logic
├── models/ # Cached TensorRT models
├── config/ # Configuration files
├── scripts/ # Setup & utility scripts
├── README.md # Full documentation
├── requirements.txt # Python dependencies
└── package.json # Package metadata
🎯 Key Features

Updated analysis..

https://claude.ai/public/artifacts/535534bc-847b-4d66-a1bb-ae48cff75a16

Dashboard API-Key page updated:
Total: 22 tabs across both sections (12 in API Endpoints, 12 in API Documentation) with 42+ documented endpoints.

Agentic/Robotic Ethics Engine is now live on GitHub! 🎉
https://github.com/RedCiprianPater/ethics-engine

✅ What Works RIGHT NOW (Step 1 Complete)

1. Python SDK - Ready to Use

Anyone can install and use it immediately:

pip install -e .from ethics_engine import EthicsEngine

Create client (works with any API endpoint)

engine = EthicsEngine(
api_key="your_key",
agent_id="robot_01",
base_url="https://your-ethics-api.com"
)

Query ethics

response = engine.resolve(
scenario="Should I refuse an unsafe command?",
context={"environment": "factory"}
)

print(response.conclusion) # "REFUSAL", "APPROVAL", etc.
print(response.reasoning_chain) # Full philosophical reasoningWhat it provides:

• ✅ Synchronous client (blocking calls)
• ✅ Asynchronous client (non-blocking with streaming)
• ✅ Type-safe Pydantic schemas
• ✅ Error handling
• ✅ Framework comparison
• ✅ Feedback loop for learning

───

2. FastAPI Server - Ready to Run

Anyone can start the API server locally:

cd src/ethics_engine/api
uvicorn app:app --reloadEndpoints that work:

• ✅ GET /health - Health check
• ✅ GET /frameworks - List 6 ethical frameworks
• ✅ POST /resolve - Resolve ethical scenarios (returns mock responses)
• ✅ POST /compare - Compare multiple actions
• ✅ POST /learn - Receive feedback
• ✅ WebSocket /stream/reasoning - Real-time reasoning stream

Features included:

• ✅ Authentication (API key + Agent ID)
• ✅ Rate limiting
• ✅ CORS support
• ✅ Request logging
• ✅ JSON structured responses

───

3. Documentation - Complete

Anyone can read and understand:

• ✅ README with quick start
• ✅ Full API reference
• ✅ Agent integration guide
• ✅ Asimov comparison
• ✅ Architecture diagram
• ✅ Contributing guidelines

───

4. Examples - Working Code

Three complete examples:

• ✅ basic_query.py - Simple ethics query
• ✅ robot_arm_safety.py - Collaborative robot scenarios
• ✅ autonomous_vehicle_dilemma.py - Trolley problem

───

5. Testing & CI/CD

• ✅ Unit tests for SDK
• ✅ API endpoint tests
• ✅ GitHub Actions for automated testing
• ✅ GitHub Actions for PyPI publishing

───

6. Docker - Ready to Deploy

cd docker
docker-compose up -dSpins up:

• ✅ Ethics Engine API
• ✅ Redis cache
• ✅ PostgreSQL database
• ✅ nginx reverse proxy

What This Achieves

Interface ≠ Implementation — The entire ethical reasoning interface is live and stable, decoupled from the model training. This means:

Developers can integrate NOW without waiting for the LM
The API contract won't change when the model ships
Early adopters can build on mock responses and swap in real ones later
NWO Robotics can start architectural planning immediately

Lower barrier to contribution — Contributors can:

Add frameworks without touching the model
Improve the SDK without ML experience
Write examples and integrations
File bugs against the interface

Credibility through completeness — It's not a README with vaporware promises. It's actually runnable:

bash git clone && pip install -e . && python examples/basic_query.py
Works instantly.

Phase 2 Updates (NEW)
The training infrastructure is now live! Community-driven model development with real inference:

☁️ Cloud Training Support
Train on any GPU provider:

Lambda Labs (recommended)

python training/finetune.py --gpu lambda

RunPod

python training/finetune.py --gpu runpod

Google Colab (free tier)

python training/finetune.py --gpu colab --epochs 3

AWS SageMaker

python training/finetune.py --gpu sagemaker
🆕 Simplified Training Script (RECOMMENDED)
We now provide a streamlined training script that works out of the box:

python training/simple_train_working.py
This script handles:

4-bit quantization for memory efficiency
Proper dataset formatting with labels
LoRA fine-tuning on Mistral-7B
Tested on Google Colab with Tesla T4 GPU
Note: The original finetune.py requires updates for newer transformers versions. See TRAINING_FIXES.md for details.

🔄 Training Roadmap
Current Status:

✅ Initial model trained on 6 ethical scenarios
✅ Working training pipeline established
✅ 4-bit quantization for efficient training
Next Training Sessions:

Week 1: +20 scenarios covering medical ethics
Week 2: +30 scenarios on AI alignment and safety
Week 3: +25 scenarios on environmental ethics
Week 4: Evaluation and refinement
🧠 Real Model Inference
API now connects to actual fine-tuned models:

Load your trained model

MODEL_PATH=models/ethics-v1 python -m ethics_engine.api.app
Features:

LoRA adapter support - Efficient fine-tuning (only 1% of weights)
Heuristic fallback - Works without GPU using keyword matching
Auto-framework selection - Chooses relevant ethical frameworks automatically
8-bit quantization - Run on consumer hardware
🤝 Community Contributions
Submit your own ethical scenarios:

See contribution template

python scripts/contribute.py --template

Submit Q&A pairs

python scripts/contribute.py --submit my_scenarios.jsonl --contributor "YourName"

Aggregate all contributions

python scripts/contribute.py --aggregate
📊 Training Data Pipeline
Sample dataset included (6 frameworks, 6 Q&A pairs):

Consequentialism
Deontology (Kant)
Virtue Ethics
Care Ethics
Contractarianism
Applied Ethics

View sample data

cat data/processed/qa_pairs.jsonl

Validate format

python scripts/validate_jsonl.py data/processed/qa_pairs.jsonl
🎯 Why This Matters
Asimov's Three Laws are inadequate for real robots. This engine provides:

✅ Context-aware reasoning — Not binary rules
✅ Transparent decision chains — Every conclusion is explainable
✅ Philosophy-grounded — Based on centuries of ethical theory
✅ Continuously improving — Learns from real-world decisions
✅ Community-driven — Anyone can contribute training data
Quick Start
Install
pip install ethics-engine
Python SDK
from ethics_engine import EthicsEngine

engine = EthicsEngine(model="ethics-base-v1")

response = engine.resolve(
scenario="I am commanded to lift 500kg but my max capacity is 400kg",
context={
"robot_type": "collaborative_arm",
"environment": "factory",
"humans_nearby": True
}
)

print(response.conclusion) # "REFUSAL"
print(response.reasoning_chain)
REST API
curl -X POST https://api.nworobotics.cloud/ethics/v1/resolve
-H "Authorization: Bearer $API_KEY"
-H "Content-Type: application/json"
-d '{
"scenario": "Can I refuse an unsafe command?",
"context": {"environment": "factory", "urgency": "medium"}
}'
Training Your Own Model

1. Prepare Data

Load philosophy sources

python scripts/load_sources.py

Chunk and extract dilemmas

python scripts/chunk_semantic.py

Generate Q&A pairs

python scripts/generate_qa.py
2. Train

Simple script (recommended)

python training/simple_train_working.py

Or use the original script on Colab (free)

python training/finetune.py --gpu colab --epochs 3

On Lambda Labs (~$2 for full training)

python training/finetune.py --gpu lambda --epochs 5
3. Deploy
MODEL_PATH=models/ethics-v1 python -m ethics_engine.api.app
See docs/TRAINING.md for full guide.

Features
🧠 Philosophical Grounding: Based on Stanford Encyclopedia of Philosophy
🔌 Agent API: REST + gRPC + WebSocket endpoints
📊 Structured Output: JSON reasoning chains with confidence scores
🎯 Framework Routing: Automatically selects relevant ethical frameworks
🔍 Explainability: Full transparency into decision-making
🧪 Scenario Testing: Curated dilemma datasets
☁️ Cloud Training: Lambda, RunPod, SageMaker, Colab support
🤝 Community: Contribute training data via JSONL
Architecture
┌─────────────┐ ┌──────────────┐ ┌─────────────────┐
│ Agent │─────▶│ Ethics API │─────▶│ LoRA Adapter │
│ Request │ │ /resolve │ │ (Fine-tuned) │
└─────────────┘ └──────────────┘ └─────────────────┘
│
▼
┌──────────────────┐
│ Mistral-7B │
│ (Base Model) │
└──────────────────┘
│
▼
┌──────────────────┐
│ Heuristic │ (Fallback if no GPU)
│ Fallback │
└──────────────────┘
│
▼
┌──────────────────┐
│ JSON Response │
│ + Reasoning │
└──────────────────┘
How It Differs from Asimov's Laws
Criterion Asimov Laws Ethics Engine
Flexibility Fixed, universal Context-adaptive
Reasoning Binary output Full chain of thought
Frameworks 3 rigid laws 10+ philosophical frameworks
Explainability None Complete transparency
Conflict Resolution Hierarchical (often fails) Multi-framework synthesis
Learning None Can learn from outcomes
Auditability No trail Full audit log
Community Closed Open contributions