Ignite · Serverless Compute

Run code. Or call a model.

One serverless compute service, two surfaces. Deploy your own Python or Rust functions on demand — or call 25+ catalog models through OpenAI-compatible /v1/chat, /v1/embeddings, /v1/rerank, and /v1/predict. Same auth, same scaling, same observability. MCP-ready by default.

Deploy your first function View on GitHub

~200ms

Warm cold start

25+

Catalog models

1000

Concurrent / fn

Stitched-together stack

Lambda for code, OpenAI for models, Cohere for rerank, Whisper somewhere else. Three bills, three SDKs, three auth flows.

Ignite

One service for code and models. Functions deploy in seconds; the catalog answers on /v1/* the OpenAI SDK already speaks.

Two surfaces.
One executor pool.

Ignite gives you both halves of the AI app: bring your own code as Functions, or call our catalog through the ModelService. Same scheduler, same warm pool, same observability — and both surfaces show up to MCP-aware agents as tools.

Functions · Live

Your code, on demand

Deploy Python or Rust handlers via the CLI or gRPC. Draft → test → publish; warm executor pool returns in ~200ms. KEDA fans 50, 500, or 5000 invocations across the cluster pool without provisioning.

Models · Live

OpenAI-compatible model APIs

Call 25+ catalog models through standard endpoints — Chat Completions, Embeddings, Rerank, Transcribe, and a generic Predict for vision/NER/classify. Point your existing OpenAI or Cohere SDK at api.dodil.io and it just works.

MCP · Live

Both surfaces are agent tools

Flip mcp_enabled on a function and it shows up to agents as a callable tool — no shim. The same MCP gateway exposes catalog models alongside your functions, so agents reach code and inference through one credential.

ModelService · catalog

Every model behind a standard endpoint.

The catalog is open. New models drop in as YAML in ignite-catalog; the ModelService resolves them under the public org. Pick a category to see what's live today and which OpenAI/Cohere endpoint serves it.

Chat / Generation

POST /v1/chat/completions

qwen25-15b-q41.5B · Q4_K_M

qwen3-1.7b

gemma3-1b-it

kimi-k2-5extended thinking

Browse the full catalog: ignite model list · GET /v1/models

Polyglot by design

One executor pool. Pick your runtime.

Ignite runs every function on the same warm executor pool, whatever the runtime. Python for the obvious cases, Rust for the hot path, WASM when you want a tight sandbox, and more on the way. The scheduler, the invocation API, and the observability surface stay the same across all of them.

runtimes

handler.py

python

def handle(event, ctx):
    name = event.get("name", "world")
    return {"message": f"Hello, {name}!"}

$ ignite function create hello --runtime python

executor pool · all runtimes

~200ms warm · the same code path, regardless of runtime

Same scheduler. Same executor pool. Same ~200ms warm path. Your runtime just plugs in.

The lifecycle

Draft. Publish. Invoke. Stream.

Step 01

Draft

Save your handler to a mutable draft slot. Compile (Rust only) and test against a payload — none of it touches production.

Step 02

Publish

`ignite draft publish` promotes the draft to an immutable, versioned release. Older versions are kept (10 by default) for instant rollback.

Step 03

Invoke

Call sync (wait for result), async (fire and forget), or fan-out via run-once. The scheduler routes to a warm executor in the dedicated pool.

Step 04

Stream

`ignite execution stream` tails logs over NATS JetStream in real time. Per-function metrics, traces, and rollups land in PostgreSQL automatically.

Two surfaces, one credential.

Functions ship through the CLI — scaffold, save the draft, publish. Models ship through standard HTTP endpoints any OpenAI/Cohere SDK already speaks. The Python SDK (decorator-based) is in development; it's shown in the last Functions tab.

Functions · CLI

# 1. Scaffold a function — pick a runtime at create time.
ignite function create hello --runtime python

# 2. Write a plain handler. No magic imports, no decorators.
cat > handler.py <<'PY'
def handle(event, ctx):
    name = event.get("name", "world")
    return {"message": f"Hello, {name}!"}
PY

# 3. Save your code to the mutable draft slot.
ignite draft save org:hello --code handler.py

# 4. (Optional) Test the draft against a payload before shipping.
ignite draft test org:hello --payload '{"name": "Dodil"}'

# 5. Publish as an immutable, versioned release.
ignite draft publish org:hello

Models · HTTP

# OpenAI-compatible Chat Completions — point any OpenAI SDK at Ignite.
curl https://api.dodil.io/v1/chat/completions \
  -H "Authorization: Bearer $DODIL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-1.7b",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user",   "content": "Summarize Dodil Ignite in one line."}
    ],
    "max_tokens": 64,
    "stream": false
  }'

# Streaming? Same endpoint, set "stream": true — Ignite returns
# SSE-equivalent chunks token-by-token until finish_reason is set.

Try it

One function. Tool, API, batch job.

Toggle mcp_enabled to see the function flip from a regular service into an agent tool. Hit Invoke for a single dedicated execution, or fan it out across 50 concurrent runs and watch the wall clock barely move.

function: org:hello

runtime: python · tier: SMALL · mode: dedicated

Registered as MCP tool org__hello — agents can discover and invoke this function with no extra setup.

handler.py · org:hello

$ ignite function create hello --runtime python

def handle(event, ctx):
    name = event.get("name", "world")
    return { "message": f"Hello, {name}!" }

flags
$ignite function update org:hello--mcp-enabled true

payload

Hit Invoke to send a single request to the dedicated executor pool.

Massively parallel · 50 concurrent invocationsKEDA fans the work across the executor pool — wall clock barely moves.

per-invocation duration · ms

180-200

200-220

220-240

240-260

260-280

280+

Demo runs entirely in your browser — durations match the real docs/PERFORMANCE.md warm-pool benchmark. No requests leave the page.

Questions, answered.

Ship code. Call a model. Hand both to an agent.

Join Early Access for $500 in credits, priority onboarding, and a direct line to the engineering team. Your first function — and your first model call — are one credential away.

Get early access Read the docs

DODILFrom data to intelligence.

Home Pricing Progress