Agentic Workflow

Every orchestration tool solves one pattern.

Airflow runs DAGs but requires Kubernetes. Temporal does durable execution but needs a server. GitHub Actions does CI but can't branch dynamically. Zapier connects triggers but can't roll back. Every tool requires infrastructure, and none is AI-native.

The current fixes don't work. YAML pipelines are rigid -- you can't add a step at runtime. Cron schedulers don't know about holidays or service health. Retry logic is one-size-fits-all. Approval gates are yes/no checkboxes. And no orchestration tool lets your AI agent create, modify, and reason about the workflow itself.

AgenticWorkflow orchestrates every coordination pattern in a single engine. DAGs, state machines, batch processing, stream processing, fan-out/fan-in -- all through 124 MCP tools. Not "configure a YAML file." Your agent thinks about workflows -- plans them, validates them, executes them, retries intelligently, rolls back on failure, and learns from every execution.

Problems Solved (Read This First)

• Problem: every orchestration tool requires infrastructure (Kubernetes, servers, cloud services). Solved: single .awf binary file. Zero infrastructure. Works offline.
• Problem: workflow tools handle one pattern (DAGs OR state machines OR batch, never all). Solved: one engine for all patterns -- DAGs, FSMs, batch, stream, fan-out, triggers, schedules.
• Problem: retries are "3 times with backoff" regardless of failure type. Solved: failure-classified retry -- different strategies for rate limits, network errors, auth failures.
• Problem: when step 5 fails, steps 1-4 leave partial results with no undo. Solved: per-step rollback actions, executed in reverse order with cryptographic receipts.
• Problem: "deploy to production" auto-executes with no human check. Solved: approval gates with escalation chains, conditional auto-approval, and time-bounded decisions.
• Problem: "what happened at 3am that broke production?" requires log archaeology. Solved: structured, queryable audit trail. "Show all workflows that touched the billing DB."

use agentic_workflow::{Workflow, StepNode, StepType, Edge, EdgeType};
use agentic_workflow::engine::DagEngine;

let mut engine = DagEngine::new();

// Define a deployment pipeline
let mut wf = Workflow::new("deploy-pipeline", "Build, test, approve, deploy");
let build = StepNode::new("Build", StepType::Command {
    command: "cargo".into(), args: vec!["build".into(), "--release".into()],
});
let test = StepNode::new("Test", StepType::Command {
    command: "cargo".into(), args: vec!["test".into()],
});
let approve = StepNode::new("Approve", StepType::ApprovalGate {
    approvers: vec!["[email protected]".into()], timeout_ms: Some(3600_000),
});
let deploy = StepNode::new("Deploy", StepType::McpTool {
    sister: "connect".into(), tool: "deploy".into(),
    params: serde_json::json!({"target": "production"}),
});

let (bid, tid, aid, did) = (build.id.clone(), test.id.clone(), approve.id.clone(), deploy.id.clone());
wf.add_step(build); wf.add_step(test); wf.add_step(approve); wf.add_step(deploy);
wf.add_edge(Edge { from: bid, to: tid.clone(), edge_type: EdgeType::Sequence });
wf.add_edge(Edge { from: tid, to: aid.clone(), edge_type: EdgeType::Sequence });
wf.add_edge(Edge { from: aid, to: did, edge_type: EdgeType::Sequence });

// Validate and execute
engine.register_workflow(wf).unwrap();

Four steps. One DAG. Approval gate before production. Retry intelligence. Rollback on failure. Works with Claude, Cursor, Windsurf, or any MCP client.

The 24 Capabilities

Six categories. Twenty-four capabilities. Every orchestration pattern that exists or will exist.

Core Engine (Capabilities 1-4)

Resilience (Capabilities 5-8)

Processing (Capabilities 9-11)

Governance (Capabilities 12-14)

State (Capabilities 15-16)

Intelligence (Capabilities 17-24)

Benchmarks

Rust core. In-memory engines. Real numbers from stress tests:

All stress tests measured on Apple ARM64, Rust 1.82, release profile. Every benchmark has a corresponding named test (stress_dag_1000_steps_linear_chain, stress_batch_10k_items, etc.).

Install

One-liner (desktop profile, backwards-compatible):

curl -fsSL https://agentralabs.tech/install/workflow | bash

Downloads pre-built awf and agentic-workflow-mcp binaries to ~/.local/bin/ and merges the MCP server into your Claude Desktop and Claude Code configs. If release artifacts are not available, the installer automatically falls back to cargo install --git source install.

Environment profiles (one command per environment):

# Desktop MCP clients (auto-merge Claude Desktop + Claude Code when detected)
curl -fsSL https://agentralabs.tech/install/workflow/desktop | bash

# Terminal-only (no desktop config writes)
curl -fsSL https://agentralabs.tech/install/workflow/terminal | bash

# Remote/server hosts (no desktop config writes)
curl -fsSL https://agentralabs.tech/install/workflow/server | bash

MCP Server

Any MCP-compatible client gets instant access to universal workflow orchestration. The agentic-workflow-mcp crate exposes the full engine over the Model Context Protocol (JSON-RPC 2.0 over stdio).

cargo install agentic-workflow-mcp

Configure Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "agentic-workflow": {
      "command": "agentic-workflow-mcp",
      "args": ["serve"]
    }
  }
}

Configure VS Code / Cursor

Add to .vscode/settings.json:

{
  "mcp.servers": {
    "agentic-workflow": {
      "command": "agentic-workflow-mcp",
      "args": ["serve"]
    }
  }
}

What the LLM gets

Once connected, the LLM can create workflows, validate DAGs, execute pipelines, manage state machines, approve deployments, query audit trails, and predict execution outcomes -- all backed by the same .awf binary file.

Quickstart

Create and run a workflow -- MCP tools

→ workflow_create { name: "daily-report", description: "Generate metrics" }
← { workflow_id: "wf-a1b2c3", steps: 0, status: "created" }

→ workflow_step_add { workflow_id: "wf-a1b2c3", name: "Query DB", type: "mcp_tool" }
← { step_id: "s-d4e5f6", position: 1 }

→ workflow_validate { workflow_id: "wf-a1b2c3" }
← { valid: true, steps: 3, edges: 2, warnings: [] }

→ workflow_run { workflow_id: "wf-a1b2c3" }
← { execution_id: "ex-g7h8i9", status: "running" }

→ workflow_progress { execution_id: "ex-g7h8i9" }
← { completed: 2, total: 3, percent: 66.7, eta_ms: 45000 }

State machine -- order lifecycle

→ workflow_fsm_create { name: "order", initial: "Created", states: [...], transitions: [...] }
← { fsm_id: "fsm-j0k1l2" }

→ workflow_fsm_transition { fsm_id: "fsm-j0k1l2", event: "pay" }
← { from: "Created", to: "Paid", timestamp: "..." }

→ workflow_fsm_transition { fsm_id: "fsm-j0k1l2", event: "ship" }
← { from: "Paid", to: "Shipped" }

How It Works

AgenticWorkflow orchestrates every coordination pattern through six subsystems:

+-------------------------------------+
|  HEADER           16 bytes          |  AWFL magic . version . counts
+-------------------------------------+
|  WORKFLOW REGISTRY                  |  All workflow definitions
|  (type u8 | length u32 | JSON | BLAKE3)
+-------------------------------------+
|  TEMPLATE LIBRARY                   |  Stored templates
+-------------------------------------+
|  EXECUTION HISTORY                  |  Past execution records
+-------------------------------------+
|  SCHEDULE TABLE                     |  Active schedules
+-------------------------------------+
|  STATE MACHINE TABLE                |  FSM definitions + current states
+-------------------------------------+
|  TRIGGER INDEX                      |  Active triggers
+-------------------------------------+
|  AUDIT LOG                          |  Structured audit events
+-------------------------------------+
|  IDEMPOTENCY CACHE                  |  Deduplication keys
+-------------------------------------+
|  VARIABLE STORE                     |  Scoped variables
+-------------------------------------+

Each section independently BLAKE3-checksummed. Corruption in one section doesn't affect others. LZ4 compression available.

Validation

One research paper:

• Paper I: AgenticWorkflow -- universal orchestration engine (10 pages, 8 figures, 11 tables, real stress test data)

Repository Structure

agentic-workflow/
├── Cargo.toml                      # Workspace root
├── crates/
│   ├── agentic-workflow/            # Core library (types, engines, resilience, governance, intelligence)
│   ├── agentic-workflow-mcp/        # MCP server (124 tools, stdio transport)
│   ├── agentic-workflow-cli/        # CLI binary (awf)
│   └── agentic-workflow-ffi/        # FFI bindings (C/Python/WASM)
├── assets/                          # Agentra design system SVGs
├── paper/                           # Research papers (I: Orchestration Engine)
├── scripts/                         # Install + guardrail scripts
├── docs/                            # Quickstart, API ref, concepts, benchmarks
└── .github/workflows/               # CI/CD pipelines

Running Tests

# All workspace tests (unit + integration)
cargo test --workspace

# Stress tests only
cargo test -p agentic-workflow stress

# Single phase
cargo test -p agentic-workflow --test phase7_stress

Deployment Model

• Standalone by default: AgenticWorkflow is independently installable and operable. Integration with AgenticMemory, AgenticCodebase, or other sisters is optional, never required.
• Zero infrastructure: No databases, no cloud services, no Kubernetes. Single .awf file holds everything.

Roadmap

The .awf File

Your agent's orchestration state. One file. Zero infrastructure.

Philosophy

"Orchestration tools shouldn't require more infrastructure than the workflows they orchestrate."

AgenticWorkflow stores everything in a single binary file. No Kubernetes. No managed services. No YAML. Your agent thinks in workflows -- let it.