Engines

An engine is an agent runtime a project runs. cloudrun doesn't assume what a runtime looks like — each engine kind brings its own substrate, its own panels, and its own API namespace (/api/<kind>/…). The contract every kind implements is deliberately small:

• Identity — id, kind, name
• nodes() — the agents it hosts, drawn on the project canvas
• A wing — that kind's entire surface (config, chat, tools, everything), used only by its own routes and panels

There are no plugin registries or capability flags: each kind is wired explicitly — the node it draws, the panels it opens, the routes it answers. One kind ships today.

Hermes

A hermes engine is a Hermes runtime on its own isolated box. cloudrun provisions the box, drives it over the runtime's own dashboard HTTP API, and hands you the box's full dashboard — one click, opens in its own tab. Everything a Hermes engine can do is exposed under /api/hermes/{engineId}/….

Hermes calls its agents profiles. Each profile is independent and owns:

• Soul — its instructions and persona
• Skills — instruction packs it can load
• Tools — toolsets and MCP servers it can call
• Integrations — connected third-party apps it acts through
• Channels — where it can be reached (Telegram, Slack, email, and more)
• Automations — scheduled prompts that run on a cron
• Memory — what it remembers across sessions
• Secrets — credentials scoped to it

New profiles start on Hermes' anonymous free model tier — no platform key ever touches the box. Connect your own providers in the Models panel for stronger models.

The baked snapshot

Boxes don't install the runtime at provision time — that would make every project wait on a full toolchain install. A golden snapshot is baked ahead of time with the runtime, its dependencies, a browser engine, and the dashboard UI already built. Provisioning restores that snapshot, which is the difference between a project starting in a minute and in half an hour. Baking is a maintenance task run when the upstream agent version moves — see Self-hosting.

Talking to the box

cloudrun speaks to each box through the runtime's own dashboard HTTP API. The client is generated from the box's OpenAPI spec, so the control plane is typed end to end against the exact runtime version it provisions. Upgrades are cheap: if a new runtime version doesn't move the API surface, the generated client doesn't change.

The box dashboard

Each box also serves the runtime's full dashboard UI. The Dashboard tab hands you its URL and credentials and opens it in a new tab — the box is its own site with its own session.

Adding an engine kind

Engine kinds are code, not configuration: a new kind means an entry in ENGINE_KINDS, a pack under lib/engines/<kind>/ implementing the contract, explicit canvas wiring for its node and panels, and an /api/<kind>/… namespace for its operations. The full recipe lives in CONTRIBUTING.md.