Keel GitHub
Open source · Single binary · Runs on Docker

Deployments your whole team can run.

Every project has one person who really knows how to deploy it. Keel turns that knowledge into a keel.yaml — and turns the file into a form that anyone, including non-technical, client-facing operators, can run from a browser.

Get started Read the docs
$ curl -fsSL https://ucgeorge.github.io/keel/install.sh | sh
 keel.yaml
version: 1

deployments:
  aws-production:
    description: Deploy the API to AWS ECS.
    environment:
      dockerfile: deploy/aws.Dockerfile   # the tools live here
    steps:
      - name: Authenticate
        run: ./deploy/aws-login.sh
      - name: Deploy
        run: ./deploy/release.sh
    variables:
      AWS_ACCESS_KEY_ID:
        secret: true
        validation: {pattern: "AKIA[0-9A-Z]{16}"}
        manifest:
          why: Authenticates with your AWS account.
          how: IAM → Users → programmatic access.
      AWS_REGION:
        type: select
        default: us-east-1
        options: [us-east-1, {value: eu-west-1, label: Europe}]
      IMAGE_TAG:
        deploy_time: true
    outputs:
      SERVICE_URL: {label: Service URL}
 aws-production / client-acme
••••••••••••••••••
Must match AKIA[0-9A-Z]{16} · saved — leave blank to keep
Europe ▾
Default: us-east-1
ops@acme
must be a valid email address
asked every time you deploy
Ready to deploy Deploy now
The steps, the CLIs, the six variables, the paragraph in the README that says "then run this script" — it all lives in one person's head. When they're away, nobody deploys.

The file is the source of truth

Deployments are declared in keel.yaml the way services are declared in a compose file. It is versioned, reviewed, and diffable — nothing is configured by clicking.

Nobody installs the tools

Each deployment names a Dockerfile with every CLI the steps need. Keel builds it and runs the steps inside. The person pressing Deploy needs a browser.

Values live with the target

A client, an environment, a region — each target keeps its own encrypted values and its own run history. Same steps, different destinations.

How it works

Describe once. Deploy from anywhere.

Describe the deployment

Write the environment, the ordered steps, and the variables — with types, validation, secrets, defaults, and the text a client will read. keel validate checks the whole file at once.

Keel renders the form

Run keel dev or open Keel Cloud. Every variable becomes a field; required ones are marked, formats are shown up front, secrets are masked. Create a target and fill it in — or hand over the generated manifest.

Anyone deploys

Press Deploy. The image builds, the steps run with every variable exported, the log streams live with secrets redacted, and the outputs land on the page with copy buttons. If it fails, the people who asked to know get an email — with a plain-language explanation of why.

What's in the box

The parts a real deployment needs

Not a CI system and not a PaaS — the layer that makes an existing deployment safe for other people to run.

Typed, validated variables

Text, number, email, URL, boolean, select, multi-line. Regex patterns with custom messages, ranges, lengths. The form shows the rule before you type and never loses what you entered.

Secrets, handled

Encrypted at rest with AES-256-GCM, masked in the form, redacted from every log line, never echoed back — and never printed by the CLI.

Targets

One deployment, many destinations. Each target stores its own values and history, shows whether it's ready, and deploys with one click from the list.

Live runs

Build, then steps, each with its own status. Logs stream as they happen and are kept, and every run records the inputs it ran with. Cancel removes the container. Nothing runs anywhere you don't control.

Outputs

export SERVICE_URL=… in a step and it appears on the run page with a copy button — kept per run, secret ones behind a reveal control.

Variable manifests

Generate the document you send a client: every value they must supply, why it's needed, and how to get it — in their language, without the repository.

Deploy-time & conditional

Ask for an image tag on every deploy. Show a destroy confirmation only when Action is destroy. Conditions chain and are validated for cycles.

Docker-defined environments

The Dockerfile is the environment. awscli, gcloud, terraform, kubectl — whatever the steps need, versioned with the code, identical on every machine.

Headless CLI

keel deploy production --target client-acme runs the same steps in the same image from a terminal or CI, with the same validation.

Email notifications

Your own SMTP server, and each recipient picks the events they care about — a deploy started, succeeded, or failed; a repository, target, or member changed. The failure email carries the inputs, the failed step, and the log tail.

AI insights on failed runs

Point Keel Cloud at any OpenAI-compatible model and a failed run gets a plain-language explanation: what happened, the likely cause, what to do next — on the run page and in the failure email. Generated once per run, secrets redacted first.

Built for AI coding agents

Keel ships agent skills for Claude Code, Codex, Cursor, Gemini CLI, Copilot and others. Ask an agent to "make this project deployable with Keel" and it writes a correct keel.yaml and environment image — and validates them.

Two editions, one engine

Start on a laptop. Grow into a team.

keel dev

Keel Dev

The local UI for one repository. Author, validate, and run deployments on your machine; state lives in .keel/ next to the code.

  • One binary, no accounts, no server
  • Edit keel.yaml, refresh — re-read on every load
  • Vendor it into a repo so the team runs make keel-dev

Quickstart →

keel-cloud

Keel Cloud

Self-hosted, multi-user, multi-repository. The same UI, backed by PostgreSQL, for a team — or a company and its clients.

  • Organizations, roles, and deploy / configure scopes
  • Any git host over HTTPS, or a GitHub App with push-triggered deploys
  • Email notifications per event, and AI explanations of failed runs from any OpenAI-compatible model
  • Deploys itself: one Keel run stands up a production instance on Google Cloud for about $35/month

Keel Cloud docs →

Install

One command. Then keel dev.

A single static binary for macOS, Linux, and Windows on amd64 and arm64. Docker is the only thing it needs to run a deployment.

macOS & Linux 
curl -fsSL https://ucgeorge.github.io/keel/install.sh | sh
Windows (PowerShell) 
irm https://ucgeorge.github.io/keel/install.ps1 | iex
Go 
go install github.com/UcGeorge/keel/cmd/keel@latest

Prefer a download? Every release has archives and checksums for each platform. Then cd into a repository and run keel init — the quickstart takes it from there.