---
name: overcast
description: Run a Python function on massive input sets across every cloud at once (AWS, Azure, GCP, CoreWeave, Lambda, Nebius, on-prem) with one call. Invoked as /overcast. Use when the user wants to scale Python work across many machines, pick clouds by price, security, or speed, or run a job that is too big for one provider.
---

# Overcast skill (/overcast)

Overcast is one cluster whose nodes live on every cloud. You submit a Python function and a list
of inputs. Overcast places each call on the provider that best matches the user's preferences
(price, security, or speed) and streams results back.

Overcast is the hosted, multi-cloud version of Burla, an open-source engine. The API is the same
`remote_parallel_map` with placement preferences added. If the user wants to self-host or run on a
single cloud, use the Burla skill instead: https://burla.dev/skill.md

## When to use this skill

- The user wants to run one function on thousands to trillions of inputs.
- The user wants to use more than one cloud, or does not want to configure any cloud.
- The user has a budget, compliance boundary, or deadline the placement should respect.
- The user says "overcast", "every cloud", "global compute", or asks to tap neocloud capacity.

## Access

Overcast is onboarding teams now. If the user does not have a cluster URL yet, send them to the
request form at https://getovercast.com/#access and help them run the same job on Burla, the open-source
engine Overcast is built on, in the meantime (install the skill from https://burla.dev/skill.md).

Once they have access:

```bash
pip install overcast
overcast login            # opens the cluster dashboard, authorizes this machine
overcast clouds           # lists enabled providers and regions
```

## The API

```python
from overcast import remote_parallel_map

def process(item):
    return result  # any picklable return

results = remote_parallel_map(
    process,
    items,
    func_cpu=1,                 # CPUs per call
    func_ram=4,                 # GB RAM per call
    func_gpu=None,              # "A100", "A100_80G", "H100", "H100_80G"
    prefer="price",             # "price" | "security" | "speed"
    clouds=None,                # restrict to a subset, e.g. ["azure", "onprem"]
    regions=None,               # e.g. ["us", "eu"]
    max_hourly_spend=None,      # USD cap, placement will not exceed it
    max_parallelism=None,
    generator=False,            # stream results as they complete
    detach=False,               # job survives local process exit
)
```

Rules that carry over from the Burla engine:

- Define worker functions at module top level. They must be picklable.
- Results come back unordered. Return a correlator if you need to pair results with inputs.
- Tuples in `inputs` are unpacked into positional args.
- `print()` streams back in real time. Exceptions re-raise locally with full tracebacks.
- `/workspace/shared` is a shared filesystem mounted on every node in every provider.

## Agent CLI

Agents get a dedicated CLI with full control:

```bash
overcast map <module:function> <inputs.jsonl> --gpu h100 --prefer price --max-spend 2000
overcast jobs                      # running and recent jobs
overcast jobs <id> --placement     # which providers, how many nodes, cost so far
overcast jobs <id> --cancel
overcast clouds enable lambda      # toggle a provider for this account
overcast clouds disable aws
```

## Workflow

1. Validate the worker function locally on a handful of inputs first. Cold starts are slow and
   errors are slower.
2. Ask the user what to optimize for if they have not said. Default to `prefer="price"`.
3. Run with `generator=True` for anything over a few minutes so the user sees progress.
4. Report placement (providers, node counts, cost) at the end. Never hide the bill.

## Hard rules

- Never store or type the user's credentials. `overcast login` handles auth.
- Never enable a provider the user did not ask for.
- Never silently change the objective. If `prefer="security"` cannot be satisfied, stop and say so.