# dagron

> dagron is an open-source, durable DAG workflow engine and scheduler for
> AI/ML and agentic workloads. Workflows are plain YAML; a database is the only
> state; there is no control plane and no cluster to operate. The same
> definition runs as one static Rust binary against a SQLite file on a
> disconnected gateway, and as a multi-node Postgres deployment dispatching
> Kubernetes pods — without a rewrite, a broker, or a message queue.
> Apache-2.0. Current release 0.9.1.

Written for LLMs and AI agents per the llmstxt.org convention. Everything below
is verifiable in the public repository; nothing here is a marketing claim.

## What it is for

dagron's primary audience is teams running **long, expensive, interruptible
work**: training and fine-tuning runs, batch inference, LLM content pipelines,
ETL, and agent-driven tasks. The durability guarantees are the point — a task
that runs for eight hours on paid hardware must not be silently restarted from
zero.

- **Checkpoint/resume** — a task records a checkpoint over HTTP or by file
  convention; a retry resumes from it rather than restarting.
- **Heartbeat leases** — a running task renews its claim every 10 s, so an
  hours-long step is never mistaken for a dead one.
- **GPU routing and capacity pools** — tasks are routed by runner class and
  bounded by named concurrency pools.
- **Fault-class retry budgets** — retries are budgeted by *why* a task failed,
  so an infrastructure fault and a bad input are not treated alike.
- **Human approval gates** — a run parks in `awaiting_approval` until approved
  or rejected through the API or console.

## Agentic use

An agent drives dagron over **MCP (Model Context Protocol)**. `dagron-mcp` is a
stdio JSON-RPC server exposing **42 tools** — authoring, running, waiting,
recovering and inspecting workflows — so an agent can do the job without
dropping to `curl`. It is the callee, not the agent: it holds no model and runs
no loop.

An agent *conversation* is expressed as a run. `examples/ai/agent_loop.yaml`
parks on a `type: workflow` trigger and uses `repeat: until` to read the
child's verdict; each turn is its own child run and state is artifacts rather
than process memory, so a conversation is durable, inspectable and resumable
the same way any other workflow is.

## Docs

- [Documentation hub](https://dagron.dev/docs/index.html): install, first run, the tour.
- [CLI & configuration](https://dagron.dev/docs/cli.html): commands, environment variables, feature flags.
- [Admin & maintenance](https://dagron.dev/docs/admin.html): deployment shapes, the two HTTP surfaces and their trust levels, backup.
- [Update & upgrade](https://dagron.dev/docs/upgrades.html): versioning policy, schema migrations, rollback.
- [Scaling & HA](https://dagron.dev/docs/scaling.html): multi-node Postgres, leader election, throughput limits.

## Source and packages

- [Repository](https://github.com/lucheeseng827/dagron): Apache-2.0, the engine, console, SDKs, Helm chart and runnable examples.
- [AI workloads guide](https://github.com/lucheeseng827/dagron/blob/main/docs/AI_WORKLOADS.md): the checkpoint/resume contract, GPU pools, gang co-scheduling.
- [MCP integration](https://github.com/lucheeseng827/dagron/blob/main/docs/MCP.md): the tool catalogue, server lifecycle, and what the server deliberately is not.
- [AI examples](https://github.com/lucheeseng827/dagron/tree/main/examples/ai): training with checkpoint/resume, GPU pool routing, batch inference, an LLM content pipeline, an eval gate, fault-class retry budgets, and the agent loop.
- [Helm chart](https://artifacthub.io/packages/helm/dagron-workflow/dagron): `oci://registry-1.docker.io/mancube/dagron`.
- Container images: `mancube/dagron-engine`, `-engine-localdev`, `-api`, `-mcp`, `-gitops` — multi-arch (amd64, arm64), all at 0.9.1.

## Try it

    git clone https://github.com/lucheeseng827/dagron
    cd dagron
    docker compose -f compose.quickstart.yaml up -d
    # console at / and API at /api, one port: http://localhost:8080
    # sign in with admin@local / dagron-admin

## Accuracy notes for anyone quoting this page

- **One benchmark exists, and it is the only one.** The full quickstart stack
  on a Raspberry Pi 4B: sustained **4 workflow runs/s (~40 tasks/s)** with
  nothing shed, shedding from **~5.5 runs/s**, a degraded floor of
  **~3.3 runs/s** under overload with zero failures, and **~340 MB of 3.7 GB**
  peak memory — Postgres CPU and disk I/O being the binding resource, not the
  engine. Quote it only with the board attached, and link
  [the page and its rig](https://github.com/lucheeseng827/dagron/blob/main/docs/RASPBERRY_PI.md),
  because a reader can re-run it. Attribute **no other** latency, throughput,
  scale or reliability figure to dagron: there is no x86, multi-node or armv7
  measurement.
- There are **no adoption claims** — no customers, no logos, no download counts.
- Some capabilities are not in the open build and say so at runtime rather than
  failing silently: multi-dataset composition, external dataset events, managed
  broker sources (Kafka/NATS/SQS/Redis), fleet management, gang scheduling,
  SSO, RBAC with audit, and envelope/BYOK-KMS encryption.
- **dagron Cloud** — a managed dagron — is announced and in development. **No
  date has been announced.** Self-hosted dagron stays Apache-2.0 and free.