Scriptum — workflows + agents, one source

Write a script. Read a diagram.

A typed DSL for distributed AI workloads — workflows, agents, parallel fan-out, retries, decisions. Same script renders as code, as a graph, and as a live run trace. Calls into Ignite, Ignite Models, and K3 — the typed glue that wires every primitive together.

review_contract.scriptum · v1

same source · two views

compiles · 8 steps · 1 fan-out · 1 decision

Script

script "review_contract" {
  version = "v1"

  input {
    pdf: file
  }

  do "Extract text" with ocr_extract
    file = input.pdf
  -> text

  do "Split clauses" with split_clauses
    text          = text
    granularity   = "section"
  -> clauses

  each clause from clauses parallel 8
    do "Classify" with classify_clause
      text       = clause
      categories = ["liability", "payment", "term", "ip"]
    -> classified
  ->> findings

  decide on findings
    when contains(findings, "high_risk")
      do "Flag for review" with notify_legal
        items = findings
    otherwise
      do "Auto-archive" with archive
        items = findings
  -> result

  output = result
}

Diagram

input · pdf

↓

extract · ocr_extract

↓

split · split_clauses

↓↓

each · parallel 8

classify

classify

classify

classify

->> findings

↓

decide · risk

notify_legal

archive

↓

output · result

tools = 5·parallel = 8·retries = auto·typed I/Oedit either side → other rebuilds instantly

DSL — six shapes, one tiny verb set

Reads like a recipe.

Every workflow shape rides on the same handful of verbs. Click a tab — the script swaps to that shape and the verb palette dims everything the snippet doesn't use.

fanout.scriptumdo · each · together · from · in · -> · …

each page from pages parallel 16
  do "embed" with embed_chunk
    text = page
  -> vec
->> all_vectors

together
  do "log"    with log_event
  do "notify" with notify_slack

Verbs · grouped7 active in this tab

Step3

doemityieldsendeachtogetherrunwaitcheck

Flow2

decidewhenotherwisefrominasvia

Agents

agentplanwith llm

Errors

retryfallbackignoreerror

I/O

scriptversioninputoutputimporttoolsenvsecrets

Types

textnumberbooleanobjectlist

Arrows2

->->>=>

Comments

-- line{- block -}--- section ----- @annotation

Preview verbssoon

ask

Native — every tool is an Ignite function

Call any code, any language.

do "…" with <tool> resolves to a function published on Ignite — Python, Rust, Go, Deno, TypeScript. Typed inputs, retries, observability — all free. Publish a tool once, call it from any script.

three tools · three languages · same syntax

do "embed"  with embed_chunk     -- Python
  text = page
-> vectors

do "to PDF" with pdf_make        -- Rust
  html = template.render(data)
-> file

do "classify" with classify_text -- Deno + LLM
  text  = clause
-> tag

Tools · catalog

embed_chunk

Python

ignite

pdf_make

Rust

ignite

classify_text

Deno · TS

ignite

s3_write

Go

ignite

slack_post

Python

ignite

fetch_url

TypeScript

ignite

$ dodil ignite publish ./my-fn --lang=python

Agents + decide + plan

LLMs as first-class steps.

agent runs an LLM in a loop with tools. decide is a typed branch. plan asks an LLM to produce the next set of steps — then the runtime executes them.

agent loop · decide branch

agent "Research topic" with llm
  system = "You are a market analyst."
  task   = "Brief on {topic}, 4 sources max."
  tools  = ["web_search", "fetch_url",
            "k3.vector.search"]
  max_iterations = 6
-> brief

decide on brief.risk
  when brief.risk == "high"
    do "Escalate"  with notify_owner
  otherwise
    do "Publish"   with publish_doc

Agent run · iter 3 of 6model: llama-3-70b

[1]thoughtI need market data — try web_search first.

[1]toolweb_search("refund SaaS market 2026")

[2]thoughtGot 6 hits — pull the top 3.

[2]toolfetch_url(...) x3

[3]thoughtCross-check internal docs.

[3]toolk3.vector.search("refund clauses")

goal reached· 4 sources · brief ready · 12.4 s

Human-in-the-Loopcoming soon

Pause for a person. Resume on a click.

The ask step suspends a script, pings an approver in Slack or email, and resumes the second they pick an option. The runtime keeps the in-flight state durable for hours, days, or a timeout you set.

preview · syntax may change

deploy.scriptum · pause for human

do "Approve deployment" with ask
  prompt   = "Deploy v{version} to prod?"
  options  = ["approve", "reject", "defer"]
  timeout  = "24h"
  channels = ["slack:#releases",
              "email:ops@dodil.io"]
-> approval

when approval.choice == "approve"
  do "Roll out" with k3_deploy
otherwise
  do "Notify"   with notify_owner

Approver inbox#releases · slack

Scriptum · req_3a91 · 4m ago

Deploy v2.4.1 to prod?

Triggered by ci/release · expires in 23h 47m

state: suspended·checkpoint: durable·resume cost: $0 (no idle)

Visual editor — same script, drawn

Drag a node. Get a script.

The graph is a deterministic projection of the AST. Drop a new node on the canvas and the script updates. Edit the script and the canvas redraws. There's no separate stored graph format — the .scriptum file is the source of truth.

Palette+ do+ decide+ each+ agent+ ask+ waitsynced · 0 dirty

do · fetch

do · embed

each · parallel 4

classify

classify

classify

classify

decide · score

do · publish

do · review

with: embed_chunk · in: text · out: vec[1024]

live preview
do "Fetch"   with fetch_url
do "Embed"   with embed_chunk
each item from items parallel 4
  do "Classify" with classify_text
decide on items.score
  when score > 0.8
    do "Publish" with publish_doc
  otherwise
    do "Review"  with notify_owner

graph view·script viewno separate graph format · the .scriptum file is the source of truth

Triggers — where the arrow starts

Six ways a script begins.

Each trigger is declared in the script header — Scriptum provisions the underlying plumbing on deploy. Click a spoke to inspect the wiring.

scriptum

review_msa.scriptum

8 steps · v1

declarationHTTP webhook

on http "/hooks/contract" { signed = true }

Signed inbound POST — issued URL is provisioned on deploy.

urlhttps://hooks.dodil.io/hooks/contractmethodPOST · JSON bodyauthHMAC-SHA256 · signed=trueqps cap120 / s burst · queued beyond

six declarations · one deploy · $ dodil scripts deploy review_contract provisions every spoke in one shot

Observability — run traces, retries, reasoning

Every run, fully traced.

A scripted workflow is also a trace. Every step shows duration, retries, the actual LLM reasoning, and the live mailbox state. Click any node to expand inputs, outputs, logs.

Runrun_3a91…b21e·review_contract v1·started 04m agorunning · 7 of 8 done · 1 retry

steptimeline (ms)duration

extract
320 ms

split
84 ms

classify #1
240 ms

classify #2
↻ 1
460 ms

classify #3
220 ms

classify #4
280 ms

decide
12 ms

notify_legal
…

ok · 6retried · 1running · 1click any bar → expand inputs, outputs, LLM reasoning, logs

Patterns — four shapes

Built for four jobs.

Document processing, agent orchestration, ETL on K3, approval workflows — one DSL, one runtime.

Document processing

PDFs in. Embeddings out.

each pdf from input.batch parallel 32
  do "extract" with ocr_extract
  do "embed"   with embed_chunk

parallel 32 · auto-retry · 4× faster than serial

Agent orchestration

LLM with tools, in a loop.

agent "research" with llm
  tools = ["web_search", "fetch_url"]
  max_iterations = 6

full reasoning trace · cap on iterations

ETL on K3

Tables → Vectors → Tables.

do "read"  with k3_table_query
do "embed" with embed_chunk
do "write" with k3_vector_upsert

typed I/O · backpressure · resumable

HITL soon

Approval workflows

Pause for a human.

do "approve" with ask     -- soon
  options = ["yes", "no"]
  timeout = "24h"

durable suspend · Slack / email

Pricing — pay when steps run

No cluster. No idle. No surprises.

Every step is an Ignite invocation — orchestrator, tools, and LLM tokens all bill straight through at the same rates as if you called them directly. No script surcharge.

Orchestrator

passthroughto Ignite vCPU + RAM