Yaml Based Agent Workflow Definition

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 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 “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 “agent lifecycle management with versioning, publishing, and deployment”

An AI agent development platform with all-in-one visual tools, simplifying agent creation, debugging, and deployment like never before. Coze your way to AI Agent creation.

Unique: Provides end-to-end agent lifecycle management with MySQL-backed version history, immutable published releases, and a visual agent marketplace UI, integrated into the same monorepo as the IDE

vs others: More comprehensive than Hugging Face Model Hub because it versions entire agent configurations (not just models), and simpler than Kubernetes Helm because deployment is abstracted through a UI rather than requiring YAML templating

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 “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

via “yaml-based declarative agent definition with structured execution”

** is an open source command line tool designed to be a simple yet powerful platform for creating and executing MCP integrated LLM-based agents.

Unique: Uses YAML-based declarative definitions rather than programmatic agent builders, enabling non-developers to define agents and making agent behavior transparent and auditable through version control

vs others: More auditable and reproducible than LangChain/LlamaIndex agents because agent logic is declarative YAML rather than embedded in Python code, enabling easier compliance and debugging

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

via “yaml-driven multi-agent workflow orchestration”

Communicative agents for software development

Unique: Configuration-driven architecture where YAML files define complete agent workflows without code, combined with domain-agnostic runtime that executes identical orchestration logic across software development, data visualization, 3D generation, game development, and video creation domains. Unlike Langchain/LlamaIndex which require Python chains, ChatDev 2.0 separates workflow definition from execution runtime.

vs others: Eliminates code-based agent choreography entirely through YAML configuration, enabling non-technical users to compose multi-agent workflows that Langchain/Crew AI require Python expertise to define.

via “configuration management and agent templating”

Terminal env for interacting with with AI agents

Unique: Likely implements configuration as code patterns with hot-reloading support, allowing developers to modify agent behavior without restarting the terminal session

vs others: More flexible than hardcoded agent initialization, with template support that reduces boilerplate compared to manual agent instantiation in code

via “agent composition and workflow definition”

</details>

Unique: Uses a directed acyclic graph (DAG) model for workflow definition, enabling parallel execution of independent agents and automatic dependency resolution

vs others: More structured than LangChain's sequential agent chains by supporting parallel execution and explicit dependency declaration

via “agent configuration and initialization with yaml/python dsl”

Multi-agent framework for building LLM apps

Unique: Supports both YAML and Python DSL for agent configuration with composition and runtime overrides, enabling declarative agent setup without code changes

vs others: More flexible than hardcoded agent initialization because configurations can be changed without redeployment; more accessible than pure Python APIs because YAML is human-readable

via “agent-workflow-as-directed-acyclic-graph-compilation”

Language Agents as Optimizable Graphs

Unique: Treats agent workflows as first-class optimizable graphs rather than imperative code or state machines, enabling compile-time analysis of agent dependencies and cost/latency tradeoffs before execution begins

vs others: Provides static optimization of multi-agent workflows that imperative frameworks like LangChain or AutoGen cannot achieve without runtime profiling, and offers explicit parallelization without manual async/await management

via “yaml-driven agent configuration with hot-reloading”

LLM-agnostic platform for agent building & testing

Unique: Uses a centralized Config singleton with file-watching hot-reload rather than requiring code recompilation or container restarts, enabling true configuration-as-code for agent systems with zero-downtime updates

vs others: Faster iteration than LangChain's programmatic agent definition because YAML changes don't require Python recompilation or server restart