How to Build an AI Agent with Declarative Orchestration

TL;DR — Building an AI agent involves combining a Large Language Model (LLM) with memory, tools, and a planning module. This allows the agent to reason, interact with external systems, and execute tasks autonomously. Success requires a robust orchestration layer to manage these components and ensure reliable, auditable performance.

Building effective AI agents goes beyond simply prompting a Large Language Model (LLM). It involves orchestrating a complex interplay of reasoning, memory, tool use, and external systems to achieve autonomous goals. The challenge lies in managing this complexity, ensuring reliability, and providing governance across diverse tasks.

This guide provides a practical, step-by-step approach to constructing robust AI agents. We will explore the core components of agentic design, discuss various development approaches, and demonstrate how Kestra’s declarative orchestration simplifies the creation, deployment, and management of production-ready AI agent workflows.

Understanding AI Agents and Their Core Components

An AI agent is a system that can perceive its environment, make decisions, and take actions to achieve specific goals. Unlike a simple chatbot, a true agent possesses a more sophisticated architecture.

Beyond Simple Prompts: Defining True AI Agents

A true AI agent is more than a one-shot prompt-and-response interaction. It operates within a continuous loop, often referred to as a ReAct (Reason + Act) loop, where it assesses a situation, plans its next step, executes an action, and observes the outcome to inform its subsequent decisions. The key components include:

• LLM Core: The reasoning engine, typically a powerful model like GPT-5 or Claude Opus 4, that processes information and makes decisions.
• Memory: A mechanism for the agent to retain information across multiple interactions, providing context and enabling more complex, stateful operations.
• Tools: A defined set of functions or external systems the agent can use to interact with the world, such as searching the web, querying a database, or calling an API.
• Planning: The ability to break down a high-level goal into a sequence of smaller, executable steps.
• Execution: The capacity to carry out the planned steps using its available tools.

Is ChatGPT a True AI Agent?

While ChatGPT can exhibit agent-like behaviors, it is fundamentally an LLM. It lacks the built-in, persistent memory and autonomous tool-use capabilities of a true agent. To build a functional agent, you must wrap the LLM in an external framework or orchestration platform that provides these missing components.

Why AI Agents Require Robust Orchestration

As agents move from prototypes to production systems, managing their behavior becomes critical. This is where a dedicated orchestration layer is essential for several reasons:

• State Management and Context Preservation: Agents need persistent memory across interactions. An orchestrator manages this state, ensuring the agent has the right context for each decision without requiring complex custom code.
• Tool Integration and Management: Securely connecting agents to external systems like APIs, databases, or other Kestra flows is paramount. Orchestration provides a secure, governed way to define and manage these tools.
• Error Handling and Resilience: What happens when a tool fails or an LLM gives an unexpected response? Orchestration platforms provide automatic retries, fallback mechanisms, and human-in-the-loop approval gates to ensure resilience.
• Observability and Auditability: For debugging and compliance, you need a clear record of an agent’s decisions, tool calls, and outcomes. A central control plane offers detailed logs and audit trails for every execution.
• Scalability and Resource Management: An orchestration engine can handle concurrent agent executions, manage compute resources efficiently, and scale your agentic workflows as demand grows.

Building AI Agents with Declarative Kestra: A Practical Example

Kestra provides a declarative approach to building agents, defining their entire logic—LLM, memory, and tools—in simple YAML. This makes agents easier to build, version, and govern.

Let’s build an agent that receives a user query, uses a Kestra subflow as a tool to read a document, and then summarizes it.

id: document_summarizer_agent
namespace: dev.ai.agents

description: An AI agent that summarizes a document based on a user query.

inputs:
  - id: query
    type: STRING
    description: The user's request for summarization.
  - id: document_uri
    type: STRING
    description: URI to the document to be summarized.

tasks:
  - id: ai_agent_task
    type: io.kestra.plugin.ai.agent.AIagent
    model: openai/gpt-5
    temperature: 0.7
    system: "You are a helpful assistant that can summarize documents. Use the 'read_document' tool to access the document content."
    prompt: "{{ inputs.query }}"
    memory:
      type: io.kestra.plugin.ai.agent.memory.ChatMemory
      id: chat_memory
    tools:
      - name: read_document
        description: "Reads the content of a document from a given URI and returns its text."
        parameters:
          type: object
          properties:
            uri:
              type: string
              description: "The URI of the document to read (e.g., kestra://../my_document.txt)."
          required:
            - uri
        task:
          id: read_file_tool
          type: io.kestra.plugin.core.flow.Subflow
          flowId: read_document_flow
          namespace: dev.ai.tools
          inputs:
            documentUri: "{{ tool.uri }}"

What this example demonstrates:

• Declarative YAML: The entire agent logic, including LLM configuration, memory, and tools, is defined in a human-readable YAML file. This is a core principle of agentic orchestration.
• Tool Integration: Kestra allows any flow to be exposed as a tool. Here, the agent can call a separate flow (read_document_flow) to handle file access securely. This separates the agent’s reasoning from the tool’s implementation.
• Memory Management: ChatMemory is automatically managed by Kestra, providing persistent context across agent interactions without any manual state handling.
• Version Control: Because the agent is defined as code, it can be versioned in Git, enabling GitOps practices for managing your AI systems.

Choosing the Right Approach for Your AI Agent

When building an agent, you can choose between code-first frameworks and declarative platforms.

Code-First vs. Low-Code/Declarative Platforms

Python frameworks like LangChain and LlamaIndex offer immense flexibility for developers comfortable with writing custom code. They provide libraries to chain LLM calls, manage memory, and integrate tools programmatically.

In contrast, a declarative platform like Kestra abstracts away the boilerplate code. Instead of writing Python scripts to wire components together, you define the relationships in YAML. This approach accelerates development, improves readability for non-programmers, and enforces standardized, auditable agent designs.

Cost Considerations for AI Agent Development

Is it free to build an AI agent? Not entirely. While open-source frameworks are free, you will incur costs for:

• LLM API Calls: Production agents using commercial models like GPT-5 or Claude Opus 4 are billed per token.
• Compute Resources: Running the agent and its tools requires processing power.
• Platform Licenses: Enterprise-grade orchestration platforms may have licensing fees for advanced features like RBAC, audit logs, and high availability.

Orchestrating Advanced AI Agent Capabilities

As your needs mature, you’ll want to build more sophisticated agents. Kestra’s orchestration capabilities support these advanced patterns.

Implementing Reasoning, Planning, and Multi-Agent Systems

You can chain multiple agents together in a single Kestra flow, creating a multi-agent system where each agent has a specialized role. For example, a “researcher” agent could gather information, passing its findings to a “writer” agent to synthesize a report.

Cloud-Based vs. Local LLMs for Agents

While cloud-based LLMs offer state-of-the-art performance, you may need to use local models for cost, privacy, or customization reasons. Kestra’s Docker Task Runner allows you to run any model in a containerized environment, giving you the flexibility to orchestrate both cloud and local LLMs within the same workflow.

The Five Types of AI Agents

AI agents are often categorized by their complexity and capabilities:

1. Simple Reflex Agents: Act only based on the current situation.
2. Model-Based Reflex Agents: Maintain an internal model of the world.
3. Goal-Based Agents: Formulate goals and plan actions to achieve them.
4. Utility-Based Agents: Choose actions that maximize a utility function.
5. Learning Agents: Improve their performance over time through experience.

Kestra can orchestrate all five types, from simple event-driven reflex agents to complex learning agents that trigger retraining pipelines based on performance metrics.

Real-World Impact: Use Cases for AI Agents

With a robust orchestration platform, AI agents can be deployed to solve real business problems:

• Automated Data Processing: Agents that identify, extract, and transform data from unstructured sources like PDFs or emails, then load it into a structured database.
• IT Operations and Remediation: Agents that monitor system alerts, diagnose issues by querying logs, and trigger automated runbooks to resolve them.
• Customer Support Automation: Agents that handle complex user queries by looking up information in internal knowledge bases and escalating to a human agent with full context when needed.
• Code Generation and Refactoring: Agents that assist developers by generating boilerplate code, writing unit tests, or refactoring legacy applications, all within a governed AI code generation workflow.

Related concepts

• What Are AI Agents? Definition & Examples
• What is Agentic AI? Explained Simply
• What is Agentic Orchestration? Definition & Components
• MCP Orchestration: Unifying AI Agents & Tools
• AI Code Generation Workflow: Orchestration & Governance
• Building Production-Ready AI Agents: Orchestrating Agentic Workflows with Kestra

Kestra provides the declarative control plane to build, deploy, and govern your production-ready AI agents. Explore our AI automation resources to learn more.