Yaml Based Configuration System With Agent And Workflow Definitions

via “configuration system with yaml-based model and role definitions”

All-in-one AI CLI with RAG and tools.

Unique: Uses Arc<RwLock<Config>> pattern for thread-safe configuration access across async tasks, enabling configuration updates without stopping the application. Configuration merging from multiple sources (files, environment, CLI) provides flexibility for different deployment scenarios.

vs others: More flexible than hardcoded configuration because it's declarative; more thread-safe than global mutable state because it uses Arc<RwLock<>>; more portable than environment-only configuration because it supports YAML files.

via “configuration-driven task and agent setup with yaml/json”

8-environment benchmark for evaluating LLM agents.

Unique: Separates configuration (YAML/JSON) from implementation (Python), enabling benchmark experiments to be specified declaratively without code changes. Configuration includes task selection, agent model, hyperparameters, and worker allocation, enabling reproducible and version-controlled experimental setups.

vs others: More accessible than code-based configuration because non-developers can modify YAML files; enables reproducibility through configuration versioning.

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 “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 “agent configuration builder with visual designer and schema validation”

The ultimate space for work and life — to find, build, and collaborate with agent teammates that grow with you. We are taking agent harness to the next level — enabling multi-agent collaboration, effortless agent team design, and introducing agents as the unit of work interaction.

Unique: Implements agent configuration as first-class schema-validated objects with a dual-path instantiation system supporting both visual builder UI and programmatic configuration, with built-in dependency injection for model providers, tools, and knowledge bases

vs others: Enables non-technical users to design agents through visual UI while maintaining configuration-as-code benefits through schema validation and version control, unlike pure code-based agent frameworks

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 “yaml-based configuration system with schema validation”

Open-source ChatGPT clone — multi-provider, plugins, file upload, self-hosted.

Unique: Combines YAML declarative configuration with runtime schema validation and environment variable interpolation, allowing operators to define model availability, pricing, and feature flags without touching code while catching configuration errors at startup

vs others: More operator-friendly than environment-variable-only configuration (used by some competitors) because it supports structured model definitions, pricing tiers, and feature flags in a single readable file

via “declarative yaml configuration with schema validation and env interpolation”

"🐈 nanobot: The Ultra-Lightweight Personal AI Agent"

Unique: Uses a Pydantic-based schema for declarative YAML configuration with environment variable interpolation and validation, rather than requiring code-based configuration. Configuration can be reloaded without restarting the agent.

vs others: More flexible than hardcoded configuration (like some chatbot frameworks) because YAML is human-readable and environment variables enable secrets management without code changes.

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 “declarative configuration system with environment variable binding”

Build effective agents using Model Context Protocol and simple workflow patterns

Unique: Implements a two-tier configuration system where high-level workflow/agent definitions are declarative YAML, while low-level provider/transport configuration is environment-driven. Uses JSON schema validation to catch configuration errors at startup, and supports environment variable aliases for common settings (e.g., OPENAI_API_KEY → llm.openai.api_key).

vs others: Unlike LangChain which uses Python-based configuration, mcp-agent's YAML-based system enables non-technical users to modify agent behavior and workflows without touching code, while maintaining schema validation and environment-based secret management.

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 “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 “configuration-driven agent instantiation with yaml-based system prompts”

A coding agent and general agent harness for building and orchestrating agentic applications.

Unique: Uses a multi-layer configuration resolution system (agent config → global preferences → provider registry) that enables inheritance and override patterns without requiring code, combined with system prompt templating that integrates directly into the agent initialization pipeline

vs others: Simpler than Langchain's agent factory pattern because configuration is declarative YAML rather than programmatic, and more flexible than static agent definitions because preferences can be overridden at runtime

via “yaml-based agent workflow definition”

Hey HN, we&#x27;re Jon and Kristiane, and we&#x27;re building Orloj (https:&#x2F;&#x2F;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&#x27;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&#x2F;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