> ## Documentation Index
> Fetch the complete documentation index at: https://docs.langdock.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent

> Use AI to analyze data, make decisions, generate content, and extract structured information.

<img src="https://mintcdn.com/langdock-34/cWyoB3RsITQmAUnM/images/workflows/nodes/agent.jpg?fit=max&auto=format&n=cWyoB3RsITQmAUnM&q=85&s=57e5116798473bd01464f22a0d8c2a28" alt="Agent Node" width="1920" height="903" data-path="images/workflows/nodes/agent.jpg" />

## Overview

The Agent node is where AI comes into your workflow. It can analyze text, make intelligent decisions, extract structured data, generate content, answer questions, and much more - all using natural language instructions.

<Info>
  **Best for**: Content analysis, categorization, data extraction,
  decision-making, summarization, and any task requiring intelligence.
</Info>

## When to Use Agent Node

**Perfect for:**

* Analyzing and categorizing content
* Extracting structured data from unstructured text
* Making decisions based on criteria
* Generating summaries or reports
* Sentiment analysis
* Answering questions about data
* Content generation
* Translation and language tasks

**Not ideal for:**

* Simple data transformations (use Code Node)
* Mathematical calculations (use Code Node)
* Direct API calls (use HTTP Request Node)

## Configuration

### Select or Create Agent

**Use Existing Agent**

* Choose from your workspace agents
* Inherits agent's configuration and knowledge
* Consistent behavior across chat and workflows

**Create New Agent**

* Define agent specifically for this workflow
* Configure independently
* Optimized for automation

### Agent Instructions

Provide clear instructions for what the agent should do:

**Good Instructions:**

```text theme={null}
Analyze the customer feedback and determine:
1. Sentiment (positive, neutral, negative)
2. Main topic category (product, service, pricing, support)
3. Urgency level (low, medium, high)
4. Key issues mentioned

Feedback: {{trigger.output.feedback_text}}
```

**Poor Instructions:**

```text theme={null}
Analyze this feedback: {{trigger.output.feedback_text}}
```

### Input Variables

Pass data from previous nodes to the agent:

```handlebars theme={null}
Customer: {{trigger.output.customer_name}}
Order ID: {{trigger.output.order_id}}
Issue: {{trigger.output.description}}

Please analyze this support ticket and categorize it.
```

### Structured Output (Recommended)

Define the exact structure you want from the agent:

**Why Use Structured Output:**

* Guaranteed format (always valid JSON)
* No parsing errors
* Reliable for downstream nodes
* Easier to debug

**Example:**

```json theme={null}
{
  "sentiment": "positive",
  "category": "product_feedback",
  "priority": "medium",
  "summary": "Customer loves the new feature",
  "action_needed": false
}
```

**Configure:**

1. Enable "Structured Output"
2. Define output fields:
   * Field name
   * Type (string, number, boolean, array)
   * Description

### Max Steps

The maximum number of tool call steps the agent can take during execution. This prevents runaway agents from consuming excessive resources.

**Default:** 25 steps
**Minimum:** 1

**When to adjust:**

* **Lower (5-10)**: Simple tasks with predictable tool usage
* **Default (25)**: Most use cases
* **Higher (50-100)**: Complex research or multi-step analysis tasks

### Tools & Capabilities

Enable additional capabilities for the agent. Tools are configured as an array with four types:

**Built-in Capabilities**

* **Web Search**: Agent can search the internet for fact-checking and current information
* **Code execution and file creation**: Workflow agents can run shell commands and execute code to perform calculations, transform data, and produce file outputs (CSVs, spreadsheets, documents, images, and more). This is enabled by default and does not need to be added to the tools list.

**Integration Actions**

* Add specific actions from your connected integrations
* Each action can optionally require confirmation before execution (human-in-the-loop)
* Specify which connection to use if you have multiple

**Folders**

* Attach folders so the agent can search your documents
* Agent automatically searches relevant content when answering questions

**Other Agents**

* Call other agents as tools for specialized sub-tasks
* Useful for complex workflows with multiple areas of expertise

### Error Handling

Configure how the workflow handles errors from this node:

| Strategy           | Behavior                                                 |
| ------------------ | -------------------------------------------------------- |
| **Stop** (default) | Workflow execution stops immediately on error            |
| **Callback**       | Route to an error handling branch to process the failure |
| **Continue**       | Continue execution using error output data               |

### Connection Overrides

When using integration actions, you can override which connection the agent uses for specific tools. This is useful when:

* You have multiple connections to the same integration (e.g., different Slack workspaces)
* You want the workflow to use a specific service account

### Attachments

Attach files directly to the agent node that will be available for processing. These can be:

* Files uploaded to the workflow
* Files from previous node outputs
* Static reference documents

## Example Use Cases

### Content Categorization

```text theme={null}
Agent Configuration:
- Instructions: "Categorize this article by topic and suggest tags"
- Input: {{trigger.output.article_text}}
- Model: GPT-3.5 Turbo
- Structured Output:
  {
    "category": "string",
    "tags": ["string"],
    "confidence": "number"
  }
```

### Lead Qualification

```text theme={null}
Agent Configuration:
- Instructions: "Score this lead based on company size, role, and use case"
- Input:
  Company: {{trigger.output.company}}
  Role: {{trigger.output.role}}
  Use case: {{trigger.output.use_case}}
- Model: GPT-4
- Structured Output:
  {
    "score": "number (0-100)",
    "qualification": "hot|warm|cold",
    "reasoning": "string"
  }
```

### Document Summarization

```text theme={null}
Agent Configuration:
- Instructions: "Summarize this document in 3-5 bullet points"
- Input: {{trigger.output.document_text}}
- Model: Claude Sonnet
- Structured Output:
  {
    "summary_points": ["string"],
    "key_topics": ["string"],
    "word_count": "number"
  }
```

### Sentiment Analysis

```text theme={null}
Agent Configuration:
- Instructions: "Analyze sentiment and emotional tone"
- Input: {{trigger.output.customer_message}}
- Model: GPT-3.5 Turbo
- Structured Output:
  {
    "sentiment": "positive|neutral|negative",
    "emotion": "string",
    "confidence": "number"
  }
```

## Accessing Agent Output

**Without Structured Output:**

```handlebars theme={null}
{{agent_node_name.output.messages}}
```

**With Structured Output:**

```handlebars theme={null}
{{agent_node_name.output.structured.sentiment}}
{{agent_node_name.output.structured.category}}
{{agent_node_name.output.structured.summary}}
{{agent_node_name.output.structured.tags[0]}}
```

## Prompt Engineering Tips

**Be Explicit**

```text theme={null}
❌ "Analyze this text"
✅ "Analyze this customer feedback and categorize as bug, feature request, or question"
```

**Provide Context**

```text theme={null}
You are analyzing customer support tickets for a SaaS company.
Categorize by urgency based on:
- Urgent: System down, data loss, security issue
- High: Blocking user's work
- Medium: Inconvenience but has workaround
- Low: Feature request or question
```

**Use Examples**

```text theme={null}
Categorize these issues:
Example 1: "Can't log in, getting 500 error" → Urgent
Example 2: "How do I export data?" → Low

Now categorize: {{trigger.output.issue}}
```

**Constrain Output**

```text theme={null}
Respond with ONLY one of these categories: bug, feature, question
Do not explain your reasoning.
```

## Best Practices

<AccordionGroup>
  <Accordion title="Always Use Structured Output">
    For workflows, structured output is almost always better. It prevents parsing errors and makes data easier to use in subsequent nodes.
  </Accordion>

  <Accordion title="Be Specific in Instructions">
    Clear, detailed instructions lead to better results. Include examples if the task is complex.
  </Accordion>

  <Accordion title="Limit Input Length">
    Agents work best with focused inputs. If processing long documents, consider extracting relevant sections first.
  </Accordion>

  <Accordion title="Test with Real Data">
    Agent performance can vary. Test with actual data examples to ensure consistent results.
  </Accordion>

  <Accordion title="Handle Edge Cases">
    Add validation after the agent node to handle unexpected outputs or errors.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Code Node" icon="code" href="/en/using-langdock/workflows/nodes/code-node">
    Transform data before/after agent processing
  </Card>

  <Card title="Condition Node" icon="code-branch" href="/en/using-langdock/workflows/nodes/condition-node">
    Route based on agent decisions
  </Card>

  <Card title="Cost Management" icon="dollar-sign" href="/en/using-langdock/workflows/guides/cost-management">
    Optimize agent costs
  </Card>

  <Card title="Agents" icon="message-bot" href="/en/using-langdock/agents/introduction">
    Learn about using agents in workflows
  </Card>
</CardGroup>