Run any code, anywhere.

Bring whatever you've got — a Dockerfile, an SDK call, a pre-built image, or just a GitHub repo. Ignite builds it, deploys it, and scales it to zero between requests.

Start free Read docs

~/my-app — ignite

ignite

# Decorate any callable, then deploy programmatically.
import dodil_ignite as ignite

@ignite.function(name="hello", resource_tier=ignite.ResourceTier.SMALL)
def hello(event, ctx):
    name = event.get("name", "World")
    return {"message": f"Hello, {name}!"}

client = ignite.IgniteClient()           # reads ~/.ignite/config.yaml
function_id = client.deploy(hello)       # → "org:hello"
result = client.invoke(function_id, {"name": "Dodil"})
# → {"message": "Hello, Dodil!"}

Same artifact, same runtime — pick the doorway you're comfortable with.cli-ignite@1

The problem

Agents don’t call tools anymore — they write code and run it.

The new consumer of compute is an agent shipping code on a user’s behalf. It has to run instantly and be reachable — or the agent times out.

Agents now write one program that calls many tools and run it in a sandbox — not slow tool-by-tool calls.

CodeAct: 98% fewer tokens

A runtime that takes seconds to start kills the agent — it times out or burns tokens waiting.

<100ms cold start

Every agent needs a throwaway computer, reachable over the internet, billed only when it runs.

sandbox demand +375%/yr

Ignite runs any code — from an agent, an image, a Dockerfile or GitHub — massively parallel, scaled to zero, with a live URL in milliseconds.

How it works

Four ways in.
One build pipeline.

Whichever path you start from, Ignite turns it into a cached OCI image and rolls it out per region — same artifact, same runtime, same scale-to-zero behaviour.

Python SDK

CLI draft

Dockerfile

GitHub repo

Ignite build & deploy

OCI image · cached layers · per-region rollout

Autoscaling pods

UK · EU

KEDA scales replicas to load · idle pods drop to zero

Under the hood

Fast compile, or full image.
Same runtime either way.

SDK functions take a fast compile path through a compiler pod — no Dockerfile required. Dockerfile, BYO image, and GitHub deploys go through the Ignite builder (Dockerfile or Buildpacks). Both land in the same gateway-routed runtime with scale-to-zero.

Code → compiler pod → OCI artifact.

SDK functions skip the Docker dance. A compiler pod produces a tiny OCI artifact that runs on the standard Ignite runtime image — no Dockerfile, no builder, no per-build image cache.

Cold start~5 s on cold node · tens of ms warmBest forFunction-style workloads, glue code, small services.Triggered by$ ignite deploy ./fn (SDK)

01

Your code

Python / Rust

02

Compiler pod

produces artifact

03

Runtime

shared image

Same runtime layer — gateway-routed HTTP, KEDA scale-from-zero, per-cluster ActiveCache, regional pinning. The runtime doesn't care which path produced the artifact.

Runtime