Yaml Based Workflow Definition With Low Code Agent Configuration

via “configuration-driven agent definition with yaml/json config files”

Google's agent framework — tool use, multi-agent orchestration, Google service integrations.

Unique: Enables configuration-driven agent definition through YAML/JSON files with support for inheritance and templating, allowing non-developers to configure agents without code changes. Separates agent configuration from implementation.

vs others: More accessible than code-based agent definition — non-technical users can configure agents through configuration files, whereas code-based approaches require programming knowledge

via “configuration-driven framework setup with yaml-based customization”

Microsoft's code-first agent for data analytics.

Unique: Uses YAML-based declarative configuration for roles, prompts, and plugins, enabling non-developers to customize agent behavior and enabling configuration version control without code changes

vs others: More accessible than LangChain's Python-based configuration (which requires code changes) by using declarative YAML; more flexible than environment variables by supporting complex nested configurations

via “workflows: single-task agents for documentation, testing, and code maintenance”

AI test generation and code integrity analysis.

Unique: Workflows are defined as shareable .toml configurations that can be version-controlled and distributed across teams. Built-in workflows for documentation, testing, and maintenance provide out-of-the-box automation without custom configuration.

vs others: More flexible than hardcoded automation because workflows can be customized and shared. More accessible than custom agents because built-in workflows provide templates for common tasks.

via “configuration system with yaml-based declarative setup and environment variable overrides”

An open-source long-horizon SuperAgent harness that researches, codes, and creates. With the help of sandboxes, memories, tools, skill, subagents and message gateway, it handles different levels of tasks that could take minutes to hours.

Unique: Uses hierarchical YAML configuration with environment variable overrides, enabling deployment flexibility without code changes. Supports conditional loading of tools, skills, and models based on configuration, allowing the same codebase to serve different use cases.

vs others: More flexible than hardcoded configurations because changes don't require recompilation. More maintainable than environment-variable-only configs because YAML provides structure and documentation.

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 “reusable workflow automation for repetitive code tasks”

Qodo is the AI code review platform that catches bugs early, reduces review noise, and helps maintain code quality across fast-moving, AI-driven development. Qodo’s VSCode plugin enables developers to run self reviews on local code changes and resolve issues before code is committed.

Unique: Provides stateless, single-task workflow agents that can be defined as shareable `.toml` configuration files, enabling teams to standardize and distribute code automation procedures. Workflows are distinct from multi-turn Modes, focusing on specific, repeatable tasks.

vs others: More reusable than ad-hoc AI prompts because workflows are versioned and shareable; more lightweight than full CI/CD pipelines because they run locally in VSCode without external infrastructure.

via “agent linting and validation with ci/cd integration”

🎭 211 个即插即用的 AI 专家角色 — 支持 Hermes Agent/Claude Code/Cursor/Copilot 等 16 种工具，覆盖工程/设计/营销/金融等 18 个部门。含 46 个中国市场原创智能体（小红书/抖音/微信/飞书/钉钉等）

Unique: Treats agent definitions as code and applies software engineering practices (linting, CI/CD validation) to ensure quality. Unlike manual review, automated linting catches structural errors immediately and provides consistent feedback to contributors.

vs others: Faster and more consistent than manual review; catches errors before they reach the main branch; enables contributors to self-validate before submitting PRs.

via “markdown-based workflow and configuration management”

Open-source AI coworker, with memory

Unique: Uses Markdown as canonical format for all workflow and configuration storage rather than proprietary JSON/YAML, enabling seamless Git integration, human review, and portability while maintaining compatibility with Obsidian ecosystem

vs others: Enables Git-native workflow management unlike GUI-only tools, supporting code review workflows and version control while maintaining human readability superior to binary or complex JSON formats

via “yaml-driven configuration and declarative component initialization”

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

Unique: Single YAML file defines entire application including embeddings database, pipelines, workflows, agents, and API configuration; Application class automatically instantiates and wires all components without boilerplate code

vs others: Simpler than programmatic initialization because YAML is declarative and version-controllable; less flexible than code-based configuration but more reproducible and easier for non-technical users

via “custom agent and command creation with team management”

Your AI pair programmer

Unique: Supports team-level custom agent creation with centralized management and audit capabilities, enabling organizations to encode architectural patterns and workflows as reusable agents rather than ad-hoc prompts

vs others: Provides team-managed custom agents with audit trails, whereas GitHub Copilot and Codeium offer only per-user customization without organizational workflow standardization

via “configuration and verification system”

The first "code-first" agent framework for seamlessly planning and executing data analytics tasks.

Unique: TaskWeaver's configuration system externalizes all agent customization (LLM provider, plugins, roles, execution limits) into YAML, enabling non-developers to configure agents without touching code. This is more accessible than frameworks requiring Python configuration.

vs others: More user-friendly than LangChain's programmatic configuration because YAML is simpler for non-developers; easier to manage configurations across environments without code duplication.

via “yaml-based configuration system with agent and workflow definitions”

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

Unique: Implements configuration-driven agent instantiation through AgentLoader factory, enabling agents to be created from YAML without code. Supports environment-based configuration overrides for multi-environment deployments (dev/staging/prod).

vs others: More accessible than code-based configuration for non-technical users; better than hardcoded configurations for managing multiple environments; enables configuration sharing and standardization across teams

via “app.runtime.yaml manifest-driven application configuration and deployment”

An Open Agent Computer for ANY digital work.

Unique: Implements manifest-driven configuration as primary application definition mechanism, where app.runtime.yaml is the source of truth for agent capabilities, tools, and workspace structure. Manifests are parsed and validated by runtime at startup, enabling configuration-driven agent development.

vs others: Provides declarative configuration-driven agent definition through YAML manifests, whereas most agent frameworks require programmatic configuration in code, limiting accessibility to non-developers.

via “agent configuration and orchestration with yaml/json policy files”

Local-first personal agentic OS and everything app for coding, knowledge work, web design, automations, and artifacts.

Unique: Provides declarative YAML/JSON-based agent configuration with built-in orchestration and agent composition support, allowing non-technical users to define and route between agents without code, with capability-based access control integrated into configuration schema

vs others: More accessible than code-based agent definition for non-technical users, though less flexible than programmatic APIs for complex conditional logic or dynamic behavior

via “yaml-driven agent configuration with version control integration”

HyperChat is a Chat client that strives for openness, utilizing APIs from various LLMs to achieve the best Chat experience, as well as implementing productivity tools through the MCP protocol.

Unique: Implements 'AI as Code' philosophy where agent definitions are YAML files stored in Git alongside project code, enabling version control, reproducibility, and project-contextual agent behavior without requiring cloud infrastructure or proprietary agent management systems

vs others: Unlike cloud-based agent platforms (OpenAI Assistants, Anthropic Workbench), HyperChat's YAML-driven approach provides full version control, local data sovereignty, and seamless Git integration for teams that need auditable AI configurations

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 “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 “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 “agent configuration and capability declaration”

We were both genuinely impressed by Claude Code after it helped each of us fix nasty CI problems overnight. Doing those fixes manually would have taken days.After that experience, we each found ourselves struggling through Ctrl+Tab through multiple Claude Code windows in our terminals. While we enjo

Unique: Declarative agent configuration with capability-based routing, allowing tasks to be matched to agents based on declared capabilities rather than manual assignment. Likely uses a schema validation library (JSON Schema or similar) to ensure configuration correctness.

vs others: Simpler than programmatic agent setup and enables non-technical users to configure agent fleets through configuration files

via “workspace and personality configuration with yaml schema”

Teleton: Autonomous AI Agent for Telegram & TON Blockchain

Unique: Provides a single config.yaml file that centralizes all agent configuration (workspace, LLM, Telegram, TON, plugins, access control) with JSON schema validation and environment variable substitution, enabling reproducible deployments

vs others: LangChain requires programmatic configuration; Teleton's YAML-based approach enables non-technical users to configure agents and supports infrastructure-as-code patterns