• Docs
  • Changelog
Sign in
Get started
    • Home
    • Your first deploy
    • Free instances
    • Platform features by plan
    • Use with coding agents
    • FAQ
    • Templates
      • Migrate from…
        • Heroku
        • Railway
    • Compute plans
    • SandboxesBeta
      • Service types
        • Which to use?
        • Static sites
        • Web services
        • Private services
        • Background workers
        • Cron jobs
        • Workflows
        • Multi-service architectures
      • Data storage
        • Render Postgres
        • Render Key Value (Redis®-compatible)
        • Persistent disks
    • How deploys work
    • Supported languages
    • Git providers (GitHub, etc.)
    • Build pipeline
    • Deploy hooks
    • Monorepo support
    • Troubleshooting deploys
      • Previewing changes
        • Single-service previews
        • Preview environments (multi-service)
      • Docker deploys
        • Overview
        • Deploy a registered image
        • Using secrets
      • Runtime
        • Native runtimes
        • Environment variables & secrets
        • Default environment variables
    • Intro to sandboxes
    • Limits & pricing
      • How to…
        • Create & configure sandboxes
        • Execute commands
        • Upload and download files
        • Manage snapshots
      • Use with…
        • Claude Managed Agents
        • Cursor Cloud Agents
        • OpenAI Agents API
      • SDK/CLI reference
        • TypeScript SDK
        • Python SDK
        • CLI commands
    • Intro to workflows
    • Tutorial
    • Limits & pricing
      • How to…
        • Define tasks
        • Define flowsNew
        • Trigger runs
        • Develop locally
      • SDK reference
        • TypeScript SDK
        • Python SDK
      • Example workflows
        • TypeScript examples
        • Python examples
    • Overview
    • Create & connect
    • Database credentials
    • Extensions
    • Version upgrades
    • Logical replication
    • Legacy instance types
      • Database recovery
        • Recovery & backups
        • High availability
      • Database performance
        • Read replicas
        • Connection pooling
        • Admin apps
        • Repacking tables
        • Troubleshooting performance
    • Regions
    • Inbound IP rules
    • Edge caching
    • WebSockets
    • TLS certificates
      • Custom domains
        • Overview
        • Cloudflare
        • Namecheap
        • Other DNS providers
      • Internal traffic
        • Private network
        • Private links
      • Outbound traffic
        • Default IP ranges
        • Dedicated IP addresses
        • Outbound bandwidth
        • Handling network changes
      • Static site config
        • Custom response headers
        • Redirects & rewrites
    • The Render Dashboard
    • SSH / Shell access
    • Projects & environments
      • Service actions
        • Scaling
        • Rollbacks
        • Maintenance mode
        • One-off jobs
      • Infrastructure as code
        • Blueprints overview
        • render.yaml reference
        • Terraform provider
    • In-dashboard metrics
    • Health checks
    • Uptime best practices
      • Logging
        • In-dashboard logs
        • Log streams (syslog/HTTPS)
      • OpenTelemetry (OTel) metrics
        • Provider setup
        • Metrics reference
      • Notifications
        • Webhooks
        • Email / Slack
    • MCP Server
      • Render CLI
        • Overview
        • Command reference
      • REST API
        • Overview
        • API keys
        • API reference
      • Third-party connections
        • OIDC support
        • Datadog
    • Workspaces, members, & roles
    • Login settings
    • Audit logs
      • Organizations
        • Overview
        • SAML SSO
    • DDoS protection
    • Platform maintenance
      • Compliance
        • Overview
        • HIPAA (US health data)
        • HIPAA best practices
        • Shared responsibility model
        • Pentest policy
    • Heroku vs Render
    • Vercel vs Render

Deploy QM by YC Labs

Run YC Labs' multiplayer agent harness for your team on Render.

QM is an open-source, multiplayer agent harness from YC Labs. Your team works with it in Slack and on the web. Each person and each shared room (a channel, group message, or project) gets its own memory, files, credentials, scheduled jobs, published web apps, and durable agent computer.

Render is a built-in QM hosting target. A single qm up command provisions the entire stack in your Render workspace: QM's core service, a Render Postgres database, object storage, a Render Sandbox for each agent computer, and a separate service for each app your agents publish.

QM's deployment guide is the source of truth.

This page explains how QM runs on Render and highlights the Render-specific steps. For the complete workflow, follow QM's deployment guide and its Render reference. QM changes quickly, and qm init copies the guide that matches your CLI version into your deployment repository.

What QM offers

  • Personal and shared scopes. Each person customizes the agent to be their own, and still works with it in Slack channels, group messages, and projects.
  • Slack and web. The same identity and configuration carry over between Slack and QM's web app.
  • Your models, your keys. Choose Anthropic, OpenAI, or OpenRouter, and the Pi or Claude Code harness. QM isn't tied to one model vendor.
  • Admin control. Admins set org-wide security and sharing postures and choose which harnesses and models are available.
  • Published web apps. Agents build internal apps and publish them to the right people.
  • Background work. Scheduled jobs, watches, and inbound webhooks keep running while you're away.

See the QM README for the full feature list and SECURITY.md for the threat model.

Why run QM on Render

  • Builds from Git, with no image pipeline. Render builds every QM service from a pinned commit of the QM source repository. You don't need Docker on your machine, a container registry, or a Render Blueprint.
  • Agent computers on Render Sandboxes. Each agent computer is a Render Sandbox. QM saves its state with native snapshots, so files and installed tools carry over when QM stops or replaces a sandbox.
  • One project, managed by the CLI. QM creates a single Render project and reconciles the same resources on every qm up. You don't create or connect services by hand.
  • Isolated published apps. Each app an agent publishes runs in its own network-isolated environment. Each app has a persistent disk, and Litestream continuously backs up its SQLite database.
  • Safe updates and rollbacks. QM's core service deploys with zero downtime, and Render gives the previous instance up to 300 seconds to finish in-flight turns and shut down. qm rollback redeploys an earlier release.
  • Managed HTTPS and custom domains. The default onrender.com URLs work right away. When you set your own hostnames, QM adds them as custom domains and Render manages their TLS certificates.

Architecture

qm up creates and manages these Render resources:

ComponentRender resourceWhat it doesConfig keys and defaults
coreWeb serviceQM's API, identity, policy, scheduler, and agent loop. It also serves the web app (web chat and the Admin page) and sign-in, including QM's built-in email sign-in. The optional Slack bot runs inside this service.render.corePlan (2c-4g)
PostgresRender PostgresSessions, memory, the run queue, and other durable state.render.postgresPlan, render.postgresDiskSizeGB (10 GB)
MinIOWeb service with a persistent diskS3-compatible storage for durable files, tool output, app bundles, and app backups.render.storage.plan (0.5c-512mb), render.storage.diskSizeGB (10 GB)
Agent computersRender SandboxesOne isolated computer per scope, where the agent runs commands.Created on demand in your workspace's default sandbox group
Published appsWeb service with a 1 GB disk at /dataApps that agents publish. Each app gets its own environment in the same project.render.appRegion (defaults to render.region)

Core and MinIO each run as a single instance. If you add QM plugins that run as their own services, QM deploys them as private services in the same environment, on the render.servicePlan compute plan (0.5c-512mb).

Agent computers

Render Sandboxes is in public beta.

APIs, defaults, and limits might change during the beta period.

Each new agent computer starts from a snapshot of QM's sandbox base image. Core imports that image and snapshots it once per QM release.

QM creates each computer with idle suspension turned off and a 30-day runtime timeout. Files and background processes stay in place between turns.

After an hour without use and with no running process, QM takes a checkpoint snapshot and stops the computer. The next use starts a sandbox from that checkpoint. Files carry over, but background processes don't.

Keep these behaviors in mind:

  • QM takes a checkpoint snapshot at most once every five minutes. Work done after the last checkpoint can be lost when a sandbox ends.
  • Snapshots expire. If both the sandbox and its snapshot are gone, QM refuses to start an empty replacement. Keep durable work in Git or in QM's Files.
  • Sandboxes run in your workspace's default sandbox group. The render.region setting doesn't control where sandboxes run.
  • Disposable sandboxes that QM creates for short-lived work have a 24-hour runtime timeout.

Published apps

Each published app runs as a web service with its own 1 GB persistent disk mounted at /data. Apps use SQLite at /data/app.db. Litestream backs up that database to MinIO using credentials that only Litestream receives. If the local database file is missing, the app restores it from the backup before it starts.

Because each app has a persistent disk, app updates have brief downtime. Litestream backups are asynchronous, so the most recent writes can be lost if a disk fails. Other files under /data persist on the disk but aren't backed up.

Archiving an app keeps its disk and its backup, and restoring the app reuses them.

Deploy QM on Render

QM uses paid Render resources. Your workspace needs a payment method.

QM requires paid compute plans for its services, Render Postgres, and persistent disks. Agent computers and published apps add usage-based charges. Model usage is billed separately by your model provider.

For details, see the pricing page.

Prerequisites

  • A Render workspace with a payment method, and its workspace ID (starts with tea- or usr-)
  • A Render API key for that workspace
  • An API key for your model provider: Anthropic, OpenAI, or OpenRouter
  • On your machine: Node.js 24 or later, npm, Git, and openssl. You don't need Docker.

Let a coding agent deploy it

QM is built to be deployed by a coding agent. Tell your agent:

When the agent asks for a hosting target, choose Render. The agent follows QM's deployment guide, asks you for each choice and credential, and runs the commands below.

Deploy it yourself

  1. Create an empty repository for your organization's QM deployment. Then initialize it with the Render target:

    • --repo and --branch point to the QM source code that Render builds from. Use yc-software/qm or your own fork. Render must be able to read this repository.
    • --model-provider accepts anthropic, openai, or openrouter.
  2. Add your Render API key to the generated .env file as RENDER_API_KEY. Keep this file private, and never commit it.

  3. In qm.config.jsonc, set your workspace ID and region:

    Supported regions are oregon, ohio, virginia, frankfurt, and singapore. See Render configuration for optional settings.

  4. Set your first administrator and choose how people sign in. Follow step 3 of QM's deployment guide.

    • Slack sign-in needs no email setup or DNS changes. QM recommends it if your company uses Slack.
    • QM's built-in email sign-in emails each person a one-time link. You can set up email sending later: after you deploy, npm exec qm -- admin-login prints a single-use sign-in link for the administrator.
    • Another OIDC provider, such as Google Workspace.
  5. Run QM's Render deploy sequence:

    qm up creates the project, Postgres, MinIO, and QM's core service. It initializes MinIO before it deploys core, applies database migrations, and uploads your deployment's configuration layer. qm check --live runs a real agent turn as a one-off job on the core service to confirm the deployment works end to end.

  6. Finish the remaining steps in QM's deployment guide, starting at step 4: run qm conformance, get your deployment's URLs from qm outputs --json, sign in, send a test message, configure connectors, and optionally add the Slack bot.

  7. Rerun npm exec qm -- up and confirm that it reconciles the same resources without creating new ones.

Render configuration

Set these keys in the render block of qm.config.jsonc:

KeyDescription
workspaceIdRequired. The ID of the Render workspace that owns the deployment.
source.repo, source.branchRequired. The QM source repository and branch. Each qm up resolves the branch to a single commit and builds every QM service from it. Auto-deploys are off, so qm up controls the update order.
regionThe region for QM's services, Postgres, and MinIO. Defaults to oregon.
appRegionThe region for newly published apps. Defaults to region. Each app stays in the region it was created in.
corePlanCompute plan for core. Defaults to 2c-4g, which fits QM's default of 16 run workers. If you choose a smaller plan, also lower env.core.WORKERS.
servicePlanCompute plan for plugin services. Defaults to 0.5c-512mb.
postgresPlan, postgresDiskSizeGBPlan and storage size for Render Postgres. Storage defaults to 10 GB and must be 1 GB or a multiple of 5 GB.
storage.plan, storage.diskSizeGBCompute plan and disk size for MinIO. The disk defaults to 10 GB and can't shrink.

Use current compute plan IDs like 2c-4g. QM rejects retired plan names like standard. See Compute plans.

QM's core service gets 300 seconds to shut down after Render sends it SIGTERM. To change how long core lets in-flight turns finish, set env.core.SHUTDOWN_DRAIN_MS (default 30000). Core needs up to 30 seconds after that to exit, so keep the value at 270000 or lower.

To start agent computers from a different sandbox base image, set sandbox.baseImage to an image reference pinned by digest (<repository>:<tag>@sha256:<digest>). By default, qm up uses the base image pinned by your QM CLI version. A CLI that you build from source pins no image, so this setting is required there.

Custom domains

Core serves both publicUrl and apiUrl. Both start as core's onrender.com URL, which works without any DNS changes. To use your own domains:

  1. Set publicUrl and apiUrl in qm.config.jsonc to HTTPS origins. They can share one hostname, but they can't be an apex domain and its www subdomain.
  2. Run npm exec qm -- up. QM adds each hostname to core as a custom domain and prints the DNS record to create.
  3. Create those DNS records. Until the domains are verified, sandboxes and published apps can't reach core, and qm check --live fails.
  4. Run npm exec qm -- slack render to update your Slack app manifests with the new publicUrl.

QM doesn't remove hostnames that you delete from your config. Remove them from the service in the Render Dashboard.

Operate your deployment

  • Make changes with qm up. QM records resource IDs and every release in render.resources.json. Keep this file with your deployment repository so later commands act on the same resources. QM reconciles service settings on each qm up, so prefer changing qm.config.jsonc over editing QM's services in the Render Dashboard.
  • Web app updates ship with qm up. Core serves the web app, so qm up rebuilds it along with core. qm ui publish doesn't support Render.
  • One command changes the deployment at a time. qm up, qm down, qm rollback, and qm secrets push take a lock in your deployment directory. A second command waits up to 30 seconds for the first to finish, then stops with an error.
  • MinIO upgrades are explicit. A normal qm up keeps MinIO on its current source commit. --upgrade-minio moves it to the current commit and can briefly interrupt storage access.
  • Rollbacks don't reverse data changes. qm rollback redeploys earlier service builds with your current environment values. It doesn't reverse database migrations or SQLite schema changes in published apps.
  • Suspending doesn't stop all charges. qm down suspends QM's services, but Postgres and the MinIO disk keep running and continue to incur charges.

qm down --purge permanently deletes your data.

It deletes QM's services, Postgres, the MinIO disk, and all stored objects, including app backups. Back up app data and delete published app services first; purge refuses to continue while app services remain. Purge keeps the Render project and any workspace sandboxes.

Learn more

  • QM repository
  • QM deployment guide and Render reference
  • QM CLI reference
  • Render Sandboxes
  • Projects and environments
Deploy QM by YC Labs
  • What QM offers
  • Why run QM on Render
  • Architecture
    • Agent computers
    • Published apps
  • Deploy QM on Render
    • Prerequisites
    • Let a coding agent deploy it
    • Deploy it yourself
  • Render configuration
    • Custom domains
  • Operate your deployment
  • Learn more
All Systems Operational
© Render Inc. All rights reserved.