OpenCastor

KO | EN

gitlite — search

#javascript #llm #golang #machine-learning #linux #macos #java #windows #awesome #vue #pytorch #security #openai #open-source

(★ 26)

OpenCastor — productized open-core RCAN runtime. Gateway-as-kernel + drivers + fleet + cloud bridge + UI. Layer 4 of the OpenCastor stack. See rcan.dev/compatibility for protocol versions.

OpenCastor Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<h1 align="center">OpenCastor</h1>

Productized open-core RCAN runtime — gateway-as-kernel, drivers, fleet, cloud bridge, UI. The most fully-documented RCAN runtime; not the only one.

Peer runtime: opencastor and <a href="https://github.com/RobotRegistryFoundation/robot-md">robot-md</a> are first-class peer RCAN 3.x runtimes against a single <code>ROBOT.md</code> — see <a href="https://github.com/craigm26/opencastor-ops/blob/master/PEER_RUNTIMES.md">PEER_RUNTIMES.md</a> for the side-by-side.

94,438 lines of Python · 7,334 tests · Python 3.10–3.13

---

## What is OpenCastor

OpenCastor is an open-source runtime for embodied AI. It implements the [RCAN open protocol](https://rcan.dev/spec/) and handles the hard parts: safety gates, multi-provider AI routing, hardware drivers, messaging channels, and fleet management.

Point it at any LLM (Gemini, GPT-4.1, Claude, Ollama, and 13 more) and any robot body (Raspberry Pi, Jetson, Arduino, ESP32, LEGO) via a single YAML config. Your robot answers to WhatsApp, Telegram, Discord, Slack, and Home Assistant — and learns from its own experience through the Sisyphus self-improvement loop.

> **RCAN ≠ OpenCastor.** [RCAN](https://rcan.dev) is an independent open protocol — like DNS and ICANN, but for robotics. Any robot can implement RCAN without using OpenCastor. OpenCastor is one implementation that helped inform the spec.

## Quick Start

### 1. Install

```bash
pip install opencastor==2026.4.1.0
```

### 2. Run the setup wizard

```bash
castor setup
```

The wizard will:
- Name your robot and assign an RRN (Robot Registration Number)
- Generate a config file at `~/.config/opencastor/<name>.rcan.yaml`
- Show a QR code to connect to the Fleet UI at [app.opencastor.com](https://app.opencastor.com)
- Configure your AI brain provider (Gemini, Claude, OpenAI, or local Ollama)

### 3. Start your robot

```bash
# Start the AI brain + REST API (port 8000)
castor gateway --config ~/.config/opencastor/bob.rcan.yaml

# Start the cloud bridge (connects robot to Fleet UI — outbound-only)
castor bridge --config ~/.config/opencastor/bob.rcan.yaml
```

### 4. One-command systemd setup

```bash
castor bridge setup   # generates and optionally installs systemd services
```

### Docker

```bash
docker run -it \
  -v ~/.config/opencastor:/config \
  -e OPENCASTOR_CONFIG=/config/bob.rcan.yaml \
  ghcr.io/craigm26/opencastor:2026.4.1.0 \
  castor gateway
```

| Profile | Description | Requires |
|---|---|---|
| `apple_native` | Mac with Apple Silicon (M1–M4) — runs models on-device via Apple Foundation Models. No API key needed. | macOS, Apple Silicon |
| `mlx_local_vision` | Mac with Apple Silicon — open-source models via MLX (Llama, Mistral, Qwen). More model choice than apple_native. | macOS, Apple Silicon |
| `ollama_universal_local` | Any machine — runs local models via Ollama. Works on Mac, Linux, and Windows. | [Ollama](https://ollama.com) installed |

**On Apple Silicon, `apple_native` is the default.** The wizard will ask which Apple model profile fits your use case:

| Apple Profile | Use case | Guardrails |
|---|---|---|
| `apple-balanced` ⭐ | General chat and robot commands — best starting point | Default |
| `apple-creative` | Creative tasks, less restrictive output | Permissive Content Transformations |
| `apple-tagging` | Classifying or labeling objects/scenes | Default |

## Features

- **Protocol 66 safety** — ESTOP never blocked, local safety always wins, confidence gates run on-device
- **[RCAN protocol](https://rcan.dev/compatibility)** — hybrid signing (ML-DSA-65 + Ed25519), mandatory LoA, canonical JSON wire format, §22-26 compliance builders, BLE/LoRa/MQTT carriers
- **Multi-provider AI** — Gemini, Claude, OpenAI, Ollama, MLX (Apple Silicon), Groq, DeepSeek, and 7 more; hot-swap via YAML
- **Fleet UI** — real-time fleet dashboard at [app.opencastor.com](https://app.opencastor.com); no port forwarding needed
- **SO-ARM101 arm support** — auto-detected via USB, guided setup for follower/leader/bimanual configurations
- **18 hardware presets** — Raspberry Pi, Jetson, Arduino, ESP32, LEGO Mindstorms, OAK-D, LeRobot SO-ARM101, and more
- **Self-improving loop** — Sisyphus PM→Dev→QA→Apply pipeline learns from every episode
- **Messaging channels** — WhatsApp, Telegram, Discord, Slack, Home Assistant, MQTT
- **castor setup wizard** — guided onboarding with QR codes; works headless on Pi

## Architecture

```
[ app.opencastor.com / Fleet UI ]
          │  Firebase / Firestore
          │
   [ Cloud Functions ]            R2RAM enforcement + rate limiting
          │
   [ castor bridge ]              outbound-only Firestore connection
          │
   [ castor gateway ]             FastAPI REST + messaging channels
          │
   ┌──────────────────────┐
   │   Protocol 66 Safety │       ESTOP | confidence gates | bounds
   └──────────────────────┘
          │
   [ Tiered Brain ]               Gemini / Claude / GPT / Ollama / …
          │
   [ RCAN Config + Drivers ]      .rcan.yaml → hardware abstraction
          │
   [ Robot Hardware ]             Pi / Jetson / Arduino / SO-ARM101 / …
```

## [RCAN Protocol](https://rcan.dev/compatibility) Features

- **Replay prevention** — hybrid signatures (ML-DSA-65 + Ed25519) over canonical JSON bodies
- **Level of Assurance (LoA)** — mandatory in the [RCAN protocol](https://rcan.dev/compatibility); gates control-plane operations behind HiTL authorization
- **Canonical JSON wire format** — `rcan.canonical_json(body)` produces byte-identical serialization across Python and TypeScript SDKs
- **§22-26 compliance artifacts** — emit §23 safety benchmarks, §24 IFU, §25 post-market incident reports, §26 EU register entries via `rcan.build_*` builders
- **Federation + constrained transport** — BLE / LoRa / MQTT carriers; RRN-based identity resolution via rcan.dev
- **Post-quantum ready** — NIST FIPS 204 ML-DSA-65 is the primary signing scheme (Q-Day 2029 is NOW)

## castor CLI Reference

| Command | Description |
|---|---|
| `castor setup` | Interactive onboarding wizard — config, RRN, Fleet UI QR code |
| `castor gateway` | Start AI brain + REST API + messaging channels |
| `castor bridge` | Start cloud bridge (Fleet UI connection) |
| `castor scan` | Auto-detect connected hardware (USB, I2C, V4L2) |
| `castor doctor` | System health check — providers, channels, hardware |
| `castor fix` | Auto-fix common configuration issues |
| `castor status` | Provider and channel readiness summary |
| `castor improve` | Run Sisyphus self-improvement on recent episodes |
| `castor audit --verify` | Verify audit chain integrity |
| `castor approvals` | Review and approve pending high-risk commands |
| `castor deploy` | Push config to a remote robot over SSH |
| `castor fleet` | Discover and monitor all robots on the local network |
| `castor upgrade` | Pull latest version + pip install + service restart |

Full reference: [docs.opencastor.com/runtime/cli](https://docs.opencastor.com/runtime/cli/)

## Configuration

Minimal `bob.rcan.yaml`:

```yaml
rcan_version: "3.0"
metadata:
  robot_name: bob
agent:
  provider: google
  model: gemini-2.5-flash
drivers:
  - id: wheels
    protocol: pca9685
channels: {}
```

That's it. `castor gateway --config bob.rcan.yaml` starts the REST API, messaging channels, and the self-improving loop.

Swap the AI brain with one line:

```yaml
agent:
  provider: anthropic
  model: claude-sonnet-4-6
```

## Protocol 66

Protocol 66 is RCAN's mandatory safety layer. Current OpenCastor conformance: **94%**.

Key invariants:
- ESTOP delivered at QoS 2 (EXACTLY_ONCE) — never blocked by backpressure
- Local safety always wins — cloud commands pass through the same confidence gates as local commands
- Audit chain required for all flagged commands
- `GuardianAgent` has veto authority over unsafe actions

P66 manifest: [`sbom/`](sbom/) · Full spec: [rcan.dev/docs/safety/](https://rcan.dev/docs/safety/)

## Fleet UI

**[app.opencastor.com](https://app.opencastor.com)** — sign in with Google to see your fleet.

- Real-time status cards for all registered robots
- Robot detail: telemetry, command history, chat-scope instructions
- ESTOP button on every screen
- Consent management — approve/deny R2RAM access requests
- Revocation display — shows if a robot's identity has been revoked
- LoA display — shows operator Level of Assurance on control commands

Robots connect via `castor bridge` (outbound-only Firestore). No open ports on the robot side.

## SO-ARM101 Arm Support

The LeRobot SO-ARM101 6-DOF serial bus servo arm is auto-detected via USB VID/PID (CH340, `0x1A86/0x7523`).

```bash
pip install opencastor[lerobot]
castor scan                          # detects arm + suggests preset
castor wizard --preset so_arm101     # guided config: follower / leader / bimanual
castor gateway --config so_arm101.rcan.yaml
```

`castor scan` counts connected Feetech boards and automatically suggests the right preset: single arm (follower or leader), or bimanual pair (ALOHA-style). Koch arms use the same detection path.

## Where OpenCastor sits

OpenCastor is **Layer 4** of the OpenCastor stack — the productized
robot-facing runtime. It depends on:

- [`robot-md-gateway`](https://github.com/RobotRegistryFoundation/robot-md-gateway) — Layer 3, the open safety kernel. *Same code in commercial and community deployments.*
- [`continuonai/rcan-spec`](https://github.com/continuonai/rcan-spec) — Layer 5, the wire protocol.
- [Robot Registry Foundation](https://robotregistryfoundation.org) — Layer 6, the neutral registry.

The **safety story is identical** at every tier — hobbyist running
gateway directly, or enterprise running OpenCastor full. What you
pay for is operational ergonomics, fleet scale, compliance prep,
and support.

OpenCastor is a productized open-core RCAN runtime — gateway-as-kernel plus drivers, fleet management, cloud bridge, and commercial support. RCAN-the-protocol is implementation-independent; OpenCastor is the most fully-documented runtime that speaks it.

Everything else in the ecosystem is independent; adopt one, or all seven.

| Layer | Piece | What it is |
|---|---|---|
| **Declaration** | [ROBOT.md](https://github.com/RobotRegistryFoundation/robot-md) | The file a robot ships at its root. YAML frontmatter + markdown prose. Declares identity, capabilities, safety gates. Spec + Python CLI. |
| **Agent bridge** | [robot-md-mcp](https://github.com/RobotRegistryFoundation/robot-md-mcp) | MCP server that exposes a `ROBOT.md` to Claude Code, Claude Desktop, Cursor, Zed, Gemini CLI — any MCP-aware agent. |
| **Wire protocol** | [RCAN](https://rcan.dev/spec/) | How robots, gateways, and planners talk. Signed envelopes, LoA enforcement, PQC crypto. Think HTTP for robots. |
| **Python SDK** | [rcan-py](https://github.com/continuonai/rcan-py) | `pip install rcan` — `RCANMessage`, `RobotURI`, `ConfidenceGate`, `HiTLGate`, `AuditChain`. |
| **TypeScript SDK** | [rcan-ts](https://github.com/continuonai/rcan-ts) | `npm install rcan-ts` — same API surface for Node + browser. |
| **Registry** | [Robot Registry Foundation](https://robotregistryfoundation.org) | Permanent RRN identities. Public resolver at `/r/<rrn>`. Like ICANN for robots. |
| **Productized runtime** ← *this* | [OpenCastor](https://github.com/craigm26/OpenCastor) | **This repo.** Productized open-core RCAN runtime — connects LLM brains to hardware bodies. Safety gates, multi-provider AI routing, 18+ hardware drivers, messaging channels, fleet management. |

See also: the [`ROBOT.md` quickstart](docs/robot-md-claude-code.md) — one command puts a Bob-class robot in Claude Code via the MCP bridge.

## Ecosystem (versions)

| Project | Version |
|---|---|
| **OpenCastor** (this) | v2026.4.17.0 |
| [Fleet UI](https://app.opencastor.com) | live |
| [RCAN Protocol](https://rcan.dev/compatibility) | [live matrix](https://rcan.dev/compatibility) |
| [rcan-py](https://github.com/continuonai/rcan-py) | v2.0.0 |
| [rcan-ts](https://github.com/continuonai/rcan-ts) | v2.0.0 |
| [ROBOT.md](https://github.com/RobotRegistryFoundation/robot-md) | v0.2.0 (schema v1.1) |
| [robot-md-mcp](https://github.com/RobotRegistryFoundation/robot-md-mcp) | v0.1.3 |
| [Robot Registry Foundation](https://robotregistryfoundation.org) | v3.0 |

## Contributing

OpenCastor is Apache 2.0 and community-driven.

- **Discord**: [discord.gg/jMjA8B26Bq](https://discord.gg/jMjA8B26Bq)
- **Issues**: [github.com/craigm26/OpenCastor/issues](https://github.com/craigm26/OpenCastor/issues)
- **PRs**: See [CONTRIBUTING.md](CONTRIBUTING.md)
- **Docs**: [`docs/claude/`](docs/claude/) — structure, API reference, env vars

> **Conformance is not certification.**
>
> Conformance to RCAN tracks (L1–L4 protocol, Gateway Authority, HIL Runtime Safety) is *self-asserted via signed bundles* and *independently replayable from those bundles*. Conformance is not certification. Certification requires audit by a qualified third-party body, which is intentionally out-of-scope for the foundation in 2026.

> **Where safety is actually enforced.**
>
> Physical safety is enforced at Layer 3 (`robot-md-gateway`) or Layer 4 (a runtime that embeds it, e.g., OpenCastor). Declaration alone (Layer 1) does not enforce safety. Agent host alone (Layer 2) is not the safety boundary. If a deployment lacks Layer 3, no safety claim attaches to it.

## License

Apache 2.0 · by [Craig Merry](https://github.com/craigm26)

Implements the [RCAN open protocol](https://rcan.dev/spec/). RCAN is an independent open standard — any robot or runtime can implement it.

OpenCastor

OpenCastor Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

OpenCastor

OpenCastor Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README