Skip to main content
swale
swale

GitHub Actions
for AI workloads.

Swale is a cloud where engineering teams run training, fine-tuning, evaluation, and batch inference as workflows. A workflow is a YAML graph of tasks, and a task is any container image that says what compute it wants.

See how it works

Launching August 2026.

Platform

The wiring is the product.

Most AI work already runs in containers. What teams rebuild every time is the plumbing around them, moving data between steps and standing up a server for the evaluation job to call. Swale makes that plumbing the platform. It looks like GitHub Actions on purpose, and what differs is underneath.

Weights land in the shared workspace. The server task starts on them, the next task reaches it by address, and the graph tears the server down once that task finishes. 

name: Serve a model and query it
compute_type: cpu
entry_point: main

blocks:
  main:
    tasks:
      weights:
        name: Fetch weights
        uses: swaleio/hf-download@1-0-0
        args:
          repo: meta-llama/Llama-3.1-8B-Instruct
          dest: /mnt/workspace/llama

      serve:
        name: Serve the model
        uses: swaleio/vllm-serve@1-0-0
        compute_type: gpu
        start_on: [weights]
        terminate_on: [ask]
        args:
          model: /mnt/workspace/llama
          port: "8000"

      ask:
        name: Query the model
        uses: swaleio/http-request@1-0-0
        start_on: [serve]
        args:
          url: http://${{tasks.serve.ip-address}}:8000/v1/models
          expected_status: "200"
          response_path: /mnt/workspace/models.json

One filesystem for the whole run

Every task in a run mounts the same workspace at /mnt/workspace. Twenty preprocessing tasks can write shards and the training task reads them where they landed. Nothing is uploaded between steps and no object store sits in the middle.

A task can be a server

A task that declares terminate_on runs as a long-lived service instead of a job. Start vLLM on weights an earlier task pulled into the workspace, point the evaluation tasks at its address, and the graph shuts the server down once they finish.

Any container is a task

A task names an image and that image runs under its own entrypoint. There is no SDK to adopt and no base image to inherit from, so the graph itself carries no language. Our own vLLM task is the stock vllm/vllm-openai image, unmodified.

Repositories that version your data

Datasets and model weights live in repositories that version what you push. Content-defined chunking deduplicates them, so a re-push stores only the parts that changed, and moving that data between a repository and a running task is free.

Compute declared per task

A task states the compute it wants rather than inheriting one machine shape for the whole run. Preprocessing stays small while the step that needs real hardware asks for it, and each task is scheduled on what it declared.

Logs and usage, built in

Task logs stream while the run is still executing, and every run records what it consumed. Compute is metered per task, measured from the workload itself rather than estimated from what you asked for.

Built for the work, not the wiring.

Running AI workloads today means assembling a scheduler, an object store, a model registry, and the glue that holds them together. On Swale the wiring is the product.