Agentic automation

The outcome

Automate multi-step business processes — triage, enrichment, routing, research, orchestration — with workflows that call tools and make LLM decisions in the same flow. Each run is a durable, resumable cloud job: it persists its state after every step, so it can pause for human input, retry on failure, and resume exactly where it left off instead of starting over.

Why it matters: most automation today is a pile of brittle scripts and manual hand-offs that break the moment an API hiccups, a process needs an approval, or a step has to wait hours for an answer. A durable workflow turns those long-running, multi-step processes into something reliable — it survives errors, waits without burning resources, and picks back up on its own.

What you build on Dodil

You write the process once as a typed workflow, and the platform runs it as a managed cloud job — no orchestrator to operate, no state store to wire up, no model keys to manage.

• Author the workflow in Scriptum  — a typed, purpose-built DSL that compiles to a durable cloud thread. Deterministic steps (do this, then that, in parallel, with retries) and agent/LLM steps (think → call a tool → observe → repeat, or branch on an LLM judgment) live in one language, type-checked before anything runs.
• Inference runs on Ignite Models  — every LLM decision, embedding, and classification dispatches to the managed model service. No separate inference account or keys.
• Data is read and written in K3  — native tools read and write K3 tables, object storage, and vector collections, so enrichment and routing land their results where the rest of your data lives.
• Custom tools run on Ignite Compute  — your own functions deploy as serverless tools the workflow (and its agents) can call by name.

Why it’s faster and cheaper here

Without Dodil, an agentic process is an integration project. You stand up an orchestration framework (LangChain / Temporal / Airflow), wire it to an LLM API, host your tools on separate compute, add a state/queue store to track progress, provision the compute to run it all, and thread auth through every one of those services. Then you build the hard parts yourself — durability, retry, and the resume-after-failure / wait-for-human logic — and operate the whole stack forever.

On Dodil, that collapses into the platform. The engine gives you typed steps, tool-calling, LLM decisions, and durable, resumable threads out of the box — the durability, retry, and resume logic is the runtime, not code you write. Inference, data, and custom tools are first-class on the same platform, addressed from the same workflow. One token authenticates all of it.

The result is faster to ship — you describe the process in one typed language instead of assembling and integrating a half-dozen systems, and the compiler catches mistakes before a run starts — and cheaper to run — one platform and one bill instead of an orchestrator plus an inference vendor plus tool hosting plus a state store, with no integration glue to maintain and no durability layer to build.

Build it

For the step-by-step build — authoring a .scriptum workflow that calls a tool, branches on an LLM decision, and runs as a cloud thread (from the CLI and programmatically) — see Agentic workflow.

See also

• Agentic workflow — the step-by-step build
• Scriptum  — the typed workflow and agent engine
• Ignite Models  · K3  · Ignite Compute 
• Use Cases — why Dodil ships faster and runs cheaper