Cog: Containers for machine learning

Cog is an open-source tool that lets you package machine learning models in a standard, production-ready container.

You can deploy your packaged model to your own infrastructure, or to Replicate.

Highlights

📦 Docker containers without the pain. Writing your own Dockerfile can be a bewildering process. With Cog, you define your environment with a simple configuration file and it generates a Docker image with all the best practices: Nvidia base images, efficient caching of dependencies, installing specific Python versions, sensible environment variable defaults, and so on.
🤬️ No more CUDA hell. Cog knows which CUDA/cuDNN/PyTorch/Tensorflow/Python combos are compatible and will set it all up correctly for you.
✅ Define the inputs and outputs for your model with standard Python. Then, Cog generates an OpenAPI schema and validates the inputs and outputs.
🎁 Automatic HTTP inference server: Your model's types are used to dynamically generate a RESTful HTTP API using a high-performance Rust/Axum server.
🚀 Ready for production. Deploy your model anywhere that Docker images run. Your own infrastructure, or Replicate.

How it works

Define the Docker environment your model runs in with cog.yaml:

build:
  gpu: true
  system_packages:
    - "libgl1"
    - "libglib2.0-0"
  python_version: "3.13"
  python_requirements: requirements.txt
run: "run.py:Runner"

Define how your model runs with run.py:

from cog import BaseRunner, Input, Path
import torch

class Runner(BaseRunner):
    def setup(self):
        """Load the model into memory to make running multiple inferences efficient"""
        self.model = torch.load("./weights.pth")

    # The arguments and types the model takes as input
    def run(self,
          image: Path = Input(description="Grayscale input image")
    ) -> Path:
        """Run the model"""
        processed_image = preprocess(image)
        output = self.model(processed_image)
        return postprocess(output)

In the above we accept a path to the image as an input, and return a path to our transformed image after running it through our model.

Now, you can run the model:

$ cog run -i image=@input.jpg
--> Building Docker image...
--> Running...
--> Output written to output.jpg

Or, build a Docker image for deployment:

$ cog build -t my-classification-model
--> Building Docker image...
--> Built my-classification-model:latest

$ docker run -d -p 5000:5000 --gpus all my-classification-model

$ curl http://localhost:5000/predictions -X POST \
    -H 'Content-Type: application/json' \
    -d '{"input": {"image": "https://.../input.jpg"}}'

Or, combine build and run via the serve command:

$ cog serve -p 8080

$ curl http://localhost:8080/predictions -X POST \
    -H 'Content-Type: application/json' \
    -d '{"input": {"image": "https://.../input.jpg"}}'

Why are we building this?

It's really hard for researchers to ship machine learning models to production.

Part of the solution is Docker, but it is so complex to get it to work: Dockerfiles, pre-/post-processing, Flask servers, CUDA versions. More often than not the researcher has to sit down with an engineer to get the damn thing deployed.

Andreas and Ben created Cog. Andreas used to work at Spotify, where he built tools for building and deploying ML models with Docker. Ben worked at Docker, where he created Docker Compose.

We realized that, in addition to Spotify, other companies were also using Docker to build and deploy machine learning models. Uber and others have built similar systems. So, we're making an open source version so other people can do this too.

Hit us up if you're interested in using it or want to collaborate with us. We're on Discord or email us at team@replicate.com.

Prerequisites

macOS, Linux or Windows 11. Cog works on macOS, Linux and Windows 11 with WSL 2
Docker. Cog uses Docker to create a container for your model. You'll need to install Docker before you can run Cog. If you install Docker Engine instead of Docker Desktop, you will need to install Buildx as well.

Install

Choose your platform for installation instructions.

macOS

The easiest way to install Cog on macOS is with Homebrew:

brew install replicate/tap/cog

You can also use the install script:

# bash, zsh, and other shells
sh <(curl -fsSL https://cog.run/install.sh)

# fish shell
sh (curl -fsSL https://cog.run/install.sh | psub)

# download with wget and run in a separate command
wget -qO- https://cog.run/install.sh
sh ./install.sh

Or install manually:

sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m | sed 's/aarch64/arm64/')"
sudo chmod +x /usr/local/bin/cog
sudo xattr -d com.apple.quarantine /usr/local/bin/cog 2>/dev/null || true

If you see a Gatekeeper warning saying the binary "cannot be opened because the developer cannot be verified", run:

sudo xattr -d com.apple.quarantine /usr/local/bin/cog

Linux

You can install Cog using the install script:

# bash, zsh, and other shells
sh <(curl -fsSL https://cog.run/install.sh)

# fish shell
sh (curl -fsSL https://cog.run/install.sh | psub)

# download with wget and run in a separate command
wget -qO- https://cog.run/install.sh
sh ./install.sh

Or install manually:

sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m | sed 's/aarch64/arm64/')"
sudo chmod +x /usr/local/bin/cog

Windows

Cog does not natively support Windows, but you can run it on Windows 11 using WSL 2. Once WSL 2 is set up, follow the Linux installation instructions above.

Docker

To install Cog inside a Docker image:

RUN sh -c "INSTALL_DIR=\"/usr/local/bin\" SUDO=\"\" $(curl -fsSL https://cog.run/install.sh)"

Upgrade

If you're using macOS and you previously installed Cog with Homebrew, run the following:

brew upgrade replicate/tap/cog

Otherwise, you can upgrade to the latest version by running the same commands you used to install it.

Development

See CONTRIBUTING.md for how to set up a development environment and build from source.

Next steps

Get started with an example model
Get started with your own model
Using Cog with notebooks
Using Cog with Windows 11
Browse the example models in this repo
Deploy models with Cog
cog.yaml reference to learn how to define your model's environment
Run interface reference to learn how the Runner interface works
Training interface reference to learn how to add a fine-tuning API to your model
HTTP API reference to learn how to use the HTTP API that models serve

Need help?

Join us in #cog on Discord.

Contributors ✨

Thanks goes to these wonderful people (emoji key):

_{Ben Firshman} 💻 📖	_{Andreas Jansson} 💻 📖 🚧	_{Zeke Sikelianos} 💻 📖 🔧	_{Rory Byrne} 💻 📖 ⚠️	_{Michael Floering} 💻 📖 🤔	_{Ben Evans} 📖	_{shashank agarwal} 💻 📖
_VictorXLR 💻 📖 ⚠️	_{hung anna} 🐛	_{Brian Whitman} 🐛	_JimothyJohn 🐛	_ericguizzo 🐛	_{Dominic Baggott} 💻 ⚠️	_{Dashiell Stander} 🐛 💻 ⚠️
_{Shuwei Liang} 🐛 💬	_{Eric Allam} 🤔	_{Iván Perdomo} 🐛	_{Charles Frye} 📖	_{Luan Pham} 🐛 📖	_TommyDew 💻	_{Jesse Andrews} 💻 📖 ⚠️
_{Nick Stenning} 💻 📖 🎨 🚇 ⚠️	_{Justin Merrell} 📖	_{Rurik Ylä-Onnenvuori} 🐛	_Youka 🐛	_{Clay Mullis} 📖	_Mattt 💻 📖 🚇	_{Eng Zer Jun} ⚠️
_BB 💻	_williamluer 📖	_{Simon Eskildsen} 💻	_F 🐛 💻	_{Philip Potter} 🐛 💻	_{Joanne Chen} 📖	_technillogue 💻
_{Aron Carroll} 📖 💻 🤔	_{Bohdan Mykhailenko} 📖 🐛	_{Daniel Radu} 📖 🐛	_{Itay Etelis} 💻	_{Gennaro Schiano} 📖	_{André Knörig} 📖	_{Dan Fairs} 💻

This project follows the all-contributors specification. Contributions of any kind welcome!

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

cog-0.22.0.tar.gz (19.2 MB view details)

Uploaded Aug 14, 2026 Source

Built Distribution

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

cog-0.22.0-py3-none-any.whl (42.4 kB view details)

Uploaded Aug 14, 2026 Python 3

File details

Details for the file cog-0.22.0.tar.gz.

File metadata

Download URL: cog-0.22.0.tar.gz
Upload date: Aug 14, 2026
Size: 19.2 MB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for cog-0.22.0.tar.gz
Algorithm	Hash digest
SHA256	`23f9134ec454c429ce03962be8d76faf3b22f49c22bb9ce9de12419a4b14b737`
MD5	`ccb7d0d407a39f96fb37535787041df4`
BLAKE2b-256	`25b913852c951c2db765d6deafaaec6fb4795a91bf654ae667cdf0856b91fb92`

See more details on using hashes here.

Provenance

The following attestation bundles were made for cog-0.22.0.tar.gz:

Publisher: release-publish.yaml on replicate/cog

Attestations: Values shown here reflect the state when the release was signed and may no longer be current.

Statement:
- Statement type: https://in-toto.io/Statement/v1
- Predicate type: https://docs.pypi.org/attestations/publish/v1
- Subject name: cog-0.22.0.tar.gz
- Subject digest: 23f9134ec454c429ce03962be8d76faf3b22f49c22bb9ce9de12419a4b14b737
- Sigstore transparency entry: 2458736153
- Sigstore integration time: Aug 14, 2026
Source repository:
- Permalink: replicate/cog@79dce1d3ca6242b31bd173034ad809edd12b5078
- Branch / Tag: refs/tags/v0.22.0
- Owner: https://github.com/replicate
- Access: public
Publication detail:
- Token Issuer: https://token.actions.githubusercontent.com
- Runner Environment: github-hosted
- Publication workflow: release-publish.yaml@79dce1d3ca6242b31bd173034ad809edd12b5078
- Trigger Event: release