Declarative Dag Based Workflow Definition Via Yaml

via “visual workflow orchestration with node-based dag execution”

Open-source LLM app platform — prompt IDE, RAG, agents, workflows, knowledge base management.

Unique: Uses a node factory with dependency injection to dynamically instantiate and execute workflow nodes, combined with a pause-resume mechanism via human input nodes that persists execution state — enabling non-linear workflows that can wait for external input without losing context.

vs others: More flexible than LangChain's LCEL for complex workflows because it supports visual editing, pause-resume, and built-in human-in-the-loop patterns; simpler than Apache Airflow for LLM-specific use cases because nodes are LLM-aware with native streaming and token counting.

via “dag-based visual flow composition with yaml serialization”

Visual LLM pipeline builder with evaluation.

Unique: Dual-mode YAML + visual editor with real-time synchronization, allowing both declarative (YAML) and graphical (canvas) editing of the same DAG without manual reconciliation. The YAML-first approach enables version control and diffing of pipeline changes, unlike purely visual tools.

vs others: Combines visual ease-of-use with version-controllable YAML definitions, whereas LangChain requires Python code and Zapier/Make.com lack native LLM-specific node types.

via “dag and step-based workflow definition with kubernetes crd abstraction”

Kubernetes-native workflow engine.

Unique: Uses Kubernetes CRDs as first-class workflow primitives rather than a custom resource layer, enabling workflows to be managed by kubectl, integrated with RBAC, and stored in etcd alongside other cluster resources. The workflow-controller implements a Kubernetes operator pattern with watch-reconcile loops, not a separate control plane.

vs others: Tighter Kubernetes integration than Airflow (no separate metadata DB) and simpler deployment than Prefect (no orchestration service required), but less portable across non-Kubernetes environments.

via “visual workflow orchestration with node-based dag execution”

Visual LLM app builder with pre-built workflow templates.

Unique: Uses a Node Factory with dependency injection to dynamically instantiate 8+ node types from workflow definitions, enabling extensibility without modifying core execution engine. Pause-resume mechanism via Human Input Node allows workflows to suspend execution and wait for external approval before continuing, with full context preservation.

vs others: More flexible than Zapier for AI-native workflows (supports LLM nodes, code execution, knowledge retrieval) and more visual than LangChain for non-technical users, while maintaining full auditability of execution traces.

via “declarative yaml workflow definition with pebble templating”

Unified orchestration with declarative YAML.

Unique: Uses Pebble templating engine integrated directly into RunContext for expression evaluation, enabling type-safe variable resolution and conditional logic within YAML definitions without requiring separate template preprocessing steps

vs others: Simpler than Airflow DAGs (no Python required) and more readable than Terraform for workflow logic, with native templating support built into the execution context rather than bolted on

via “configuration-driven agent and task definition with yaml”

CrewAI multi-agent collaboration example templates.

Unique: Implements configuration-driven agent definition through YAML files (gamedesign.yaml pattern) that specify agent roles, goals, backstories, tools, and task dependencies. The framework parses YAML at runtime and instantiates agents without code changes, enabling non-developers to modify agent behavior.

vs others: More accessible than code-based agent definition; enables configuration changes without developer involvement

via “agentic workflow orchestration with dag-based task planning”

Community-contributed instructions, agents, skills, and configurations to help you make the most of GitHub Copilot.

Unique: Implements DAG-based task planning with phase-based execution and event-driven hooks, enabling complex multi-agent workflows with explicit task dependencies and error handling. The Ralph Loop pattern (Reasoning → Action → Learning → Feedback) enables iterative task execution with feedback loops, allowing agents to refine their approach based on results.

vs others: More structured than sequential agent chaining because tasks are planned as a DAG with explicit dependencies; more flexible than hardcoded workflows because phase-based execution and hooks enable event-driven automation and error recovery.

via “dag-based flow definition and execution with yaml configuration”

Build high-quality LLM apps - from prototyping, testing to production deployment and monitoring.

Unique: Uses YAML-based DAG definition with automatic topological sorting and node-level caching, enabling non-programmers to compose LLM workflows while maintaining full execution traceability and deterministic ordering — unlike Langchain's imperative approach or Airflow's Python-first model

vs others: Simpler than Airflow for LLM-specific workflows and more accessible than Langchain's Python-only chains, with built-in support for prompt versioning and LLM-specific observability

via “dag-based workflow execution with conditional branching and parallel task composition”

MS-Agent: a lightweight framework to empower agentic execution of complex tasks

Unique: Implements DAG execution with lazy task evaluation — only executes tasks whose outputs are needed based on conditional branches, reducing unnecessary computation. Provides built-in visualization of workflow structure and execution traces for debugging.

vs others: Simpler than Apache Airflow for agent workflows; more flexible than linear task chains; better suited for agentic workflows than general-purpose orchestration tools by supporting agent-specific patterns like tool calling and memory sharing

via “workflow definition as code with yaml/json schema validation”

Plan-first AI workflow plugin for Claude Code, OpenAI Codex, and Factory Droid. Zero-dep task tracking, worker subagents, Ralph autonomous mode, cross-model reviews.

Unique: Implements strict schema validation for workflow definitions, catching configuration errors at definition time rather than execution time, with support for versioning and migration

vs others: More maintainable than code-based workflows because definitions are declarative and version-controllable; more flexible than GUI-based builders because YAML/JSON is text-editable

via “dag-based visual flow authoring with yaml-backed persistence”

prompt-flow

Unique: Dual-mode editing (visual + YAML) with code lens integration allows developers to switch between abstraction levels without losing fidelity; the DAG model enforces structural correctness at definition time rather than runtime, catching dependency errors early in the authoring process.

vs others: Tighter VS Code integration and YAML-first approach provides better version control and diff visibility than GUI-only flow builders like Langflow or LlamaIndex, while remaining more accessible than pure code-based frameworks.

via “workflow engine with node-based dag execution and pause-resume”

Production-ready platform for agentic workflow development.

Unique: Implements a Node Factory pattern with Dependency Injection to dynamically instantiate workflow nodes at runtime, enabling type-safe node composition and a built-in mock system for testing without external API calls. Pause-resume mechanism is first-class in the execution model, not a post-hoc addition.

vs others: More accessible than code-based orchestration frameworks (Airflow, Prefect) for non-technical users, while offering more control than simple chatbot builders through explicit node composition and conditional branching.

via “declarative dag-based workflow definition via yaml”

Self-hosted workflow engine for scripts, cron jobs, containers, and ops automation. YAML workflows, retries, logs, approvals, and optional distributed workers.

Unique: File-based YAML DAG definition with zero external dependencies — workflows are plain text artifacts that can be version-controlled, diffed, and audited like code, with cycle detection at parse time rather than runtime

vs others: Simpler and more portable than Airflow (no Python/database required) and more transparent than cloud-native orchestrators (Temporal, Prefect) because the entire workflow definition is a single readable YAML file

via “workflow definition and execution”

Paperclip CLI — orchestrate AI agent teams to run a business

Unique: Implements workflow execution as a declarative configuration layer on top of the agent orchestration system, enabling non-developers to define workflows while maintaining full agent capability

vs others: More accessible than code-based workflow definition, enabling business users to define processes while remaining more powerful than simple sequential task lists

via “yaml-based agent workflow definition”

Hey HN, we're Jon and Kristiane, and we're building Orloj (https://orloj.dev), an open-source orchestration runtime for multi-agent AI systems. You define agents, tools, policies, and workflows in declarative YAML manifests, and Orloj handles scheduling, execution, governance, an

Unique: Applies GitOps and infrastructure-as-code patterns to agent workflows, enabling version-controlled, peer-reviewed agent configurations rather than treating agent logic as ephemeral code

vs others: Differs from LangChain/LlamaIndex by prioritizing declarative YAML configuration over imperative Python chains, enabling non-engineers to modify agent behavior and supporting GitOps deployment patterns

via “yaml-based agent configuration with declarative syntax”

I'm one of the creators of The Edge Agent (TEA). We built this because we needed a way to deploy agents that was verifiable and robust enough for production/edge cases, moving away from loose scripts.The architecture aims to solve critical gaps in deterministic orchestration identified by

Unique: Uses YAML as the primary agent definition language rather than Python/JavaScript DSLs, lowering barrier to entry for non-developers while maintaining full integration with 110 built-in tools

vs others: Simpler configuration syntax than LangChain's Python-based agent builders or AutoGen's multi-agent frameworks, enabling faster iteration for configuration-driven use cases

via “yaml-driven workflow orchestration with task composition and scheduling”

All-in-one open-source AI framework for semantic search, LLM orchestration and language model workflows

Unique: YAML-first workflow definition enabling non-technical configuration of complex AI pipelines. Integrates scheduling, task dependencies, and result passing in single declarative format without requiring separate orchestration framework.

vs others: Simpler than Airflow/Prefect for lightweight workflows; YAML-native unlike code-first approaches; integrated with txtai components (no external system dependencies) but less scalable than enterprise orchestrators

via “declarative pipeline definition with dag-based execution”

Git for data scientists - manage your code and data together

Unique: Uses a declarative YAML-based pipeline model with automatic DAG construction and change detection, allowing stages to be skipped if inputs haven't changed. The Index and Graph System computes execution order and dependency relationships, while the Stage class handles actual command execution with integrated dependency/output tracking.

vs others: More Git-native and lightweight than Airflow (no scheduler needed) and simpler than Nextflow for local ML workflows, but lacks Airflow's distributed scheduling and Nextflow's container orchestration

via “declarative workflow composition with schema-based task definition”

Hey HN! I'm Akshay, and I'm launching Seer - yet another AI workflow builder with granular OAuth scopes.GitHub: https://github.com/seer-engg/seer Demo video: https://youtu.be/cmQvmla8sl0The Problem: We've been building AI workflows for the past year

Unique: Uses declarative schema-based workflow definition combined with read-only permission scopes, enabling non-technical users to compose safe, auditable AI workflows without imperative code

vs others: Simpler than general-purpose workflow engines like Airflow or Temporal because it's optimized specifically for AI agent tasks and enforces safety constraints at the schema level

via “yaml-based workflow definition with low-code agent configuration”

A framework for building multi-agent AI systems with workflows, tool integrations, and memory. #opensource

Unique: Implements YAML as a first-class configuration format with full schema support for agents, tasks, and workflows, rather than as an afterthought. YAML configurations are validated and can be introspected programmatically, enabling tooling and IDE support.

vs others: More complete YAML support than CrewAI's basic config files; lower barrier to entry than AutoGen's programmatic-only approach