Running from Docker

The standalone editor ships as a self-contained public Docker image that bundles the editor, the octo runtime binary, the dolphin test runner, and an MCP server. Run it with one command:

docker run -p 3000:3000 -v "$PWD:/work" juancavallotti/octo

Then open http://localhost:3000.

The volume mount

The mount is the flow store. Inside the container the image sets OCTO_FS_DIR=/work, so the editor reads and writes flow YAML, and the flow's resources like .env.dev and templates, as plain files under /work. Mounting a host directory there (-v "$PWD:/work") makes that directory the store: your flows stay on your disk when the container stops, ready for octo run, a git commit, or another editor session.

Mount an empty directory to start fresh, or a directory that already contains flow YAML (for example the repo's samples/) to browse and edit it.

Without a mount, flows are written to the container's own /work and are lost when the container is removed.

Environment variables

The app is configured entirely through environment variables. The image sets working defaults for all four:

Variable	Purpose	Image default
`OCTO_FS_DIR`	Directory the editor reads/writes flow YAML and resources in	`/work`
`OCTO_BIN_PATH`	Path to the `octo` binary the Run feature spawns; unset hides Run	`/usr/local/bin/octo`
`DOLPHIN_BIN_PATH`	Path to the `dolphin` test runner the Testing tab spawns	`/usr/local/bin/dolphin`
`OCTO_RUN_DIR`	Where rendered run configs and staged resources are written	`/app/.octo-run`

Outside Docker, OCTO_FS_DIR defaults to ./flows, OCTO_RUN_DIR to the OS temp directory, and both binary paths are unset. With no octo configured, the Run button and console do not appear; with no dolphin, the Testing tab still lets you write suites but its Run tests button is disabled and says why.

Three environment variables name a binary and they are not interchangeable. OCTO_BIN_PATH is the octo the app spawns for a run. DOLPHIN_BIN_PATH is the dolphin the app spawns for a test run. OCTO_PATH is the octo that dolphin drives, one process per case. The app sets it to OCTO_BIN_PATH for every test run, so the tests can never be run against a different runtime than the one the editor uses.

You can also set OCTO_DOCS_URL to a documentation site URL; the bundled MCP server surfaces it in its authoring prompt.

Passing API keys for AI flows

Runs started from the editor inherit the container's environment, so pass provider credentials with -e:

docker run -p 3000:3000 -v "$PWD:/work" \
  -e ANTHROPIC_API_KEY=sk-ant-... \
  juancavallotti/octo

Any flow that declares ANTHROPIC_API_KEY in its env: block now resolves it at run time. For values you would rather keep next to the flows than in the docker run command, use the editor's Dev .env tab instead. See Running flows.

Image tags and architectures

The image is published to public Docker Hub as juancavallotti/octo on every release, as a multi-arch build for linux/amd64 and linux/arm64, so it runs natively on both x86 and Apple Silicon / ARM hosts.

juancavallotti/octo:latest is the most recent release.
juancavallotti/octo:<version> is a specific release, e.g. 0.2.0.

Pin a version tag for reproducible setups. See Docker images for the other published images.

Running without Docker (contributors)

If you are working on Octo itself, run the editor from the repo instead. From the repo root:

task dev

This builds the octo runner and dolphin from the Go module, then starts the Next.js dev server with both wired up to absolute paths in the repo root: OCTO_BIN_PATH at bin/octo, DOLPHIN_BIN_PATH at bin/dolphin, OCTO_RUN_DIR at .octo-run, and OCTO_FS_DIR at .octo-flows.

Running the app directly (pnpm --filter standalone dev) uses the ./flows default for the flow store and leaves Run disabled unless you set OCTO_BIN_PATH yourself.