Deploy Smoke Monkey to your preferred cloud. You keep billing, networking, and infrastructure — we ship the Docker image and the deployment config for each provider.
Pick a provider below. Every option runs the same official image, persists your agents in SQLite on a mounted volume, and exposes the live WebSocket stream.
A one-click button only exists once a provider has published a template on their platform. Render is live today. Railway and Northflank need a template published to their marketplace, and a DigitalOcean 1-Click App needs Marketplace vendor approval — none of which Smoke Monkey controls. Rather than ship buttons that go nowhere, each option below states its exact status and gives you the working path today.
A working one-click deploy. Render's official Blueprint deploy URL reads the
render.yaml at the root of this repo and provisions the web service,
the persistent disk, and the health check for you.
/app/data/ws — required for live agent streamingBest fit for always-on agents: Railway exempts WebSocket connections from its idle and duration limits. The deployment config is ready — no template has been published to the Railway marketplace, so there is no one-click URL to link to.
.railway/railway.ts IaC shipped — image + 5 GB volume + health checkrailway templates publish
Launch directly on DigitalOcean App Platform via our .do/deploy.template.yaml, or provision an Ubuntu Droplet for dedicated root access and persistent SSD block storage.
Instant one-click deploy with zero build step. Koyeb directly runs the official Docker Hub image with automatic TLS, health checks, and global edge routing.
/api/spaceThe full stack is expressed as a Northflank Template — service, persistent volume, port, and health probe — and it is committed to this repo. Northflank mints share links inside a user account, so no public URL can be pre-written.
northflank.template.json committed & schema-validated
The fastest route to a hosted workspace. Render's Blueprint deploy URL is an official,
documented Render feature and reads render.yaml from this repository.
Render opens its Blueprint form pre-filled from render.yaml. No configuration needed — the disk, health check, and environment are already declared.
A persistent disk is required, and free web services cannot have one. Choose the smallest paid web service (Starter, 512 MB).
Render builds the repository Dockerfile, then gives you an *.onrender.com address. The first build takes a few minutes.
Open any agent → Settings → Provider and paste a key. It is encrypted at rest in the SQLite database on the disk.
https://render.com/deploy?repo=https://github.com/RajdeepDevelopment/smoke-monkey-canvasFree web services spin down after 15 minutes and have an ephemeral filesystem, so SQLite would be destroyed on every spin-down and redeploy. The disk also pins the service to a single instance and means a brief pause on each deploy while the new instance starts. Both are the correct trade for keeping your agents.
The Blueprint builds the repository Dockerfile. To deploy the published image
instead, swap the service for runtime: image with
image.url: docker.io/rajdeepsadhu/smoke-monkey-canvas:latest.
Note that image-backed services cannot auto-deploy when a new tag is pushed.
See render.yaml.
Railway is arguably the best fit for this app: WebSocket connections are exempt from its idle and duration limits, so an agent stream can stay open indefinitely.
Railway has no template file format. Templates are built in the Railway
dashboard, or from a live project via railway templates create, and only
then published with railway templates publish. Publishing assigns the
template a code, and railway.com/new/template/<CODE> becomes the
one-click URL. Until that publish happens there is no URL to link to, so this page
will not invent one.
Authorise the GitHub App and pick RajdeepDevelopment/smoke-monkey-canvas. Railway builds the included Dockerfile.
/app/data
Right-click the service → Attach Volume → mount path /app/data, 5 GB. Without this, agents and chat history are lost on every deploy.
RAILWAY_RUN_UID=0
Railway mounts volumes as root and this image runs as the non-root node user, so SQLite cannot write without this. Railway injects PORT automatically.
The repo contains .railway/railway.ts, which declares the image source,
the volume, the mount path, the health check, and the environment in one place.
# Install the official CLI, then authenticate
npm i -g @railway/cli
railway login
railway link # or: railway init
# Preview the plan, then provision image + volume + service
railway config plan
railway config applyThis option is for users who want their own VM / server — full root access, your own firewall, your own backups. Create a Droplet and run the production Docker stack on it.
A DigitalOcean 1-Click App is not a Docker image — it is a pre-baked Ubuntu
snapshot built with Packer, and publishing one requires approval from DigitalOcean's
Marketplace team. No such listing has been submitted, and that review is human-gated
with no published timeline. Until it exists, the honest options are a Droplet you
create yourself, or doctl with the same stack.
cloud.digitalocean.com/droplets/new?image=<slug> only resolves for slugs DigitalOcean has already published.Any size works; 1 GB RAM is a comfortable minimum. Note the public IP.
Add an A record for your hostname to the Droplet IP. Caddy needs this to obtain a Let’s Encrypt certificate.
In DigitalOcean’s firewall (and the Droplet’s own ufw). Caddy handles both HTTP and HTTPS, including the /ws WebSocket upgrade.
SSH in and bring up the compose file. It pulls the official image, mounts the data volume, and starts Caddy in front of it.
git clone https://github.com/RajdeepDevelopment/smoke-monkey-canvas.git
cd smoke-monkey-canvas/deploy
# Set SMOKE_DOMAIN to your hostname, then start
cp .env.example .env
nano .env
docker compose -f docker-compose.vps.yml up -d
Canvas itself needs no database server. If you attach SQL-based MCP servers to your
agents, start the bundled PostgreSQL with the postgres profile and set
POSTGRES_PASSWORD in .env first — the stack is pinned to
scram-sha-256, so Postgres fails loudly rather than starting passwordless.
It stays on the private Docker network and is never published to the internet.
The entire stack is representable as a single Northflank Template, and that file is
committed to this repository — a deployment service, a persistent volume mounted
at /app/data, a public HTTP port, and a readiness probe.
Northflank generates template share links inside your own team after you create the template, and that URL format is not documented publicly. Committing the template to the repo and letting Northflank’s GitOps pick it up is the supported route, so this page links to the file rather than a URL we cannot verify.
northflank.template.json lives at the repository root and validates against Northflank’s published template schema.
Run it once in the Northflank UI, or use the official CLI. The project, volume, and service are created together. northflank login opens a browser to pick an API token, so create one in Account settings → API tokens first.
Northflank generates it after creation. Anyone with a Northflank account can open it, add the template to their team, and run it.
# Create the Northflank template from the committed file
npm i -g @northflank/cli
northflank login
northflank create template -f northflank.template.json
nf-compute-50 (1 GB). The 256 MB minimum is too tight for Node plus SQLite.No provider approval, no marketplace, no waiting. Works on any machine with Docker — a VPS, a NAS, a homelab box, or your laptop.
docker run -d \ --name smoke-monkey-canvas \ --restart unless-stopped \ -p 3333:3333 \ -v smoke_canvas_data:/app/data \ rajdeepsadhu/smoke-monkey-canvas:latest
Then open http://localhost:3333. The named volume is what keeps your agents
across restarts — do not skip -v.
deploy/docker-compose.vps.yml runs the canvas image behind Caddy, which
obtains a certificate automatically and proxies the WebSocket stream.
# Production stack: canvas + Caddy with automatic TLS cd deploy cp .env.example .env # set SMOKE_DOMAIN docker compose -f docker-compose.vps.yml up -d # Add PostgreSQL for SQL-based MCP servers docker compose -f docker-compose.vps.yml --profile postgres up -d # Logs and shutdown docker compose -f docker-compose.vps.yml logs -f canvas docker compose -f docker-compose.vps.yml down
Requires Node.js 22 or newer (for the built-in node:sqlite module).
# Run instantly, no install npx smoke-monkey-canvas # Or install from source git clone https://github.com/RajdeepDevelopment/smoke-monkey-canvas.git cd smoke-monkey-canvas npm install && npm run build npm start
No matter which provider you pick, the runtime contract is identical. That is the point of shipping one image and one health endpoint.
| Requirement | Value | Why it matters |
|---|---|---|
| Docker image | rajdeepsadhu/smoke-monkey-canvas | Multi-arch: linux/amd64 and linux/arm64 |
| Listen port | PORT (default 3333) | Railway, Render, and DigitalOcean inject this automatically |
| Persistence | /app/data | SQLite database — must be a mounted volume/disk |
| Database path | SMOKE_CANVAS_DB | Set to /app/data/canvas.db on every provider here |
| Health check | GET /api/space | Readiness endpoint used by every platform |
| WebSocket | /ws | Live agent streaming — supported on all four providers |
| REST API | /api/* | Agents, sessions, skills, MCP, settings |
| Redis | Not required | No queue or cache dependency |
| PostgreSQL | Optional | Only if you attach SQL-based MCP servers to agents |
| Secrets | Encrypted in SQLite | API keys added via the UI are encrypted at rest |
Identical on every provider. Takes about two minutes.
sqlite3 canvas.db ".backup" so a bad deploy cannot cost you your workspace.Render. It uses Render’s official Blueprint deploy URL and reads the render.yaml at the root of this repository, so the whole stack is provisioned from one click.
Railway and Northflank both need a template published to their platform before a one-click URL exists, and DigitalOcean 1-Click Apps require Marketplace vendor approval. Each of those is shown with its true status and a working setup path instead of a button that would not work.
Distribution models differ. Railway and Northflank let a maintainer publish a template to a self-serve marketplace in minutes. DigitalOcean 1-Click Apps are pre-baked Ubuntu snapshots built with Packer, and becoming a Marketplace vendor requires DigitalOcean’s approval. That is a separate application with no published SLA, and no listing has been submitted, so this page does not claim otherwise.
In the meantime a plain Ubuntu Droplet gives you the same result with more control, which is what the DigitalOcean section walks you through.
Yes, as long as a persistent volume or disk is mounted at /app/data. Every option on this page configures that mount. Your agents, chat sessions, canvas positions, and encrypted API keys live in a single SQLite file there.
The one environment where this cannot work is a platform without volume support — which is why DigitalOcean App Platform is explicitly not recommended here: its filesystem is ephemeral and is wiped on every deploy.
Yes. Smoke Monkey Canvas orchestrates agents, it does not host models. Bring a key for NVIDIA, OpenAI, Anthropic, Gemini, Groq, DeepSeek, or OpenRouter — entered in the agent settings UI (encrypted at rest) or supplied as an environment variable such as OPENAI_API_KEY. If you run Ollama locally, no key is needed.
No. The cron scheduler, the WebSocket broadcast server, and all persistence run inside the single Node.js process backed by SQLite. PostgreSQL is optional and only useful if you attach SQL-based MCP servers to your agents; the Docker stack includes it behind a profile you can switch on.
No, deliberately. Smoke Monkey is built to be self-hosted, and the license does not permit offering it as a commercial hosted service. Deploy it to your own account on any of the providers above and you own the data, the keys, and the bill.
Yes. Everything is in one SQLite file. Stop the service, copy /app/data/canvas.db off the volume, start it on another provider, and place the file at the same path. The deployment configs differ, but your workspace is portable.
The Sustainable Use License. It is free for personal projects, research, and internal business tooling, and you may modify and redistribute it non-commercially. You may not offer Canvas as a commercial hosted service or SaaS product without a commercial license.
One command locally, or one click to Render. Everything else is your own server.