Orloj – agent infrastructure as code

Enables declarative specification of multi-step agent workflows using YAML configuration files, where each step defines tool invocations, conditional branching, and state transitions. The framework parses YAML schemas into executable agent graphs, supporting sequential execution, parallel branches, and loop constructs without requiring imperative code. This approach treats agent orchestration as infrastructure-as-code, enabling version control, code review, and GitOps-style deployment patterns.

Provides a registry system for declaring available tools and functions that agents can invoke, with automatic schema generation and validation. The framework accepts tool definitions (name, description, parameters, return types) and generates JSON schemas compatible with LLM function-calling APIs. Tools are bound to agent steps via references in YAML, with the framework handling parameter marshaling, type coercion, and error handling between the LLM output and actual function invocation.

Enables agents to pause execution and request human approval before proceeding with critical actions. The framework provides mechanisms for sending approval requests (via email, Slack, webhooks, or UI), waiting for human decisions, and resuming execution based on approval/rejection. Approval workflows can be conditional (only require approval for certain actions) and can include context (reason for action, impact assessment) to help humans make informed decisions.

Enables agents to execute multiple steps in parallel and combine results, supporting fan-out (one step spawns multiple parallel tasks) and fan-in (multiple parallel tasks converge into one) patterns. The framework manages parallel execution, collects results, and provides mechanisms for combining results (merge, aggregate, select best). This is useful for tasks like querying multiple APIs in parallel or running multiple agent branches simultaneously.

Enables agents to be triggered by external events (webhooks, message queues, scheduled jobs) rather than only by direct API calls. The framework listens for incoming webhooks, parses event payloads, and automatically invokes agents with event data as input. This enables event-driven architectures where agents react to external system changes (e.g., new customer signup, payment received, alert triggered).

Abstracts differences between LLM providers (OpenAI, Anthropic, local models, etc.) behind a unified interface, allowing agents to switch providers or route requests based on cost, latency, or capability requirements. The framework handles provider-specific API differences (function-calling formats, token counting, streaming behavior) transparently, enabling YAML configurations to specify provider preferences without embedding provider-specific code.

Executes agent workflows defined in YAML by maintaining execution state across steps, managing context windows, and handling step-to-step data flow. The framework tracks agent state (current step, variables, tool results, LLM responses) and provides mechanisms for passing data between steps, persisting state across invocations, and recovering from failures. Execution can be synchronous (blocking until completion) or asynchronous (with webhooks/callbacks for result notification).

Enables agents to make decisions and repeat actions based on conditions evaluated at runtime. The framework supports if/else branching (based on LLM outputs, tool results, or variables), loops (repeat steps until condition met), and switch statements (route to different steps based on categorical decisions). Conditions are expressed in a simple DSL or as references to step outputs, allowing complex workflows without imperative code.

Integrates with Git repositories to enable GitOps-style deployment of agent configurations. Changes to YAML workflow files trigger automatic deployments, with Git history serving as the audit trail for all agent behavior changes. The framework supports rollback to previous versions, branch-based testing (deploy from feature branches to staging), and pull request workflows where agent changes are reviewed before merging.

Provides built-in logging, metrics, and tracing for agent executions, capturing step-by-step execution details, LLM API calls, tool invocations, and performance metrics. The framework emits structured logs that can be sent to external observability platforms (Datadog, New Relic, etc.) and provides dashboards or CLI tools for viewing execution traces. Metrics include latency per step, token usage, cost, and error rates.

Supports templating of LLM prompts with variables that are substituted at runtime based on agent context, tool results, or user input. The framework uses a simple template syntax (e.g., {{variable_name}}) to embed variables in prompts, with support for filters (e.g., {{variable | uppercase}}) and conditional sections (e.g., {{#if condition}}...{{/if}}). This enables dynamic prompt generation without string concatenation in code.

Provides declarative error handling and retry mechanisms for agent steps, allowing configuration of retry counts, backoff strategies (exponential, linear, fixed), and fallback actions. When a step fails (tool error, LLM timeout, etc.), the framework automatically retries according to the configured policy or executes a fallback step. Error conditions can be caught and handled without terminating the entire workflow.

Manages context windows and memory for agents, tracking conversation history, tool results, and intermediate outputs across steps. The framework provides mechanisms for summarizing or pruning old context to stay within LLM token limits, storing long-term memory in external systems (databases, vector stores), and retrieving relevant context for each step. Context can be scoped to individual conversations, users, or global agent state.