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

# Autonomous Agents

> Configure agents that decide which resources and tools to use at run time

Autonomous agents handle open-ended customer conversations by deciding what to research, which tools to call, and when to respond.

Instead of starting from one fixed runbook or workflow, an autonomous agent starts from your instructions and the resources you make available: runbooks, workflows, knowledge, guidelines, guardrails, and tools.

## When to Use Autonomous Agents

Use an autonomous agent when the conversation needs judgment, research, or flexible sequencing.

| Use autonomous when                                                             | Use a workflow or runbook when                            |
| ------------------------------------------------------------------------------- | --------------------------------------------------------- |
| Customer requests vary widely                                                   | The process follows the same steps every time             |
| The agent needs to choose between multiple runbooks or workflows                | You already know the exact procedure to run               |
| The agent may need to search knowledge, call tools, then decide what to do next | Compliance requires a deterministic branch-by-branch flow |
| The same deployment handles many support topics                                 | The deployment is scoped to one known task                |

## How Autonomous Agents Work

When an autonomous agent runs, Duckie gives it the conversation, your agent instructions, and the resources enabled for that agent.

The agent can:

* Read relevant runbooks before taking action
* Follow guidelines and guardrails assigned to the agent
* Search available knowledge
* Call Duckie tools, app tools, custom tools, MCP tools, and workflows
* Delegate focused tasks to callable agents
* Send a customer response through an available responder tool
* End its turn when the work is complete

Autonomous agents also keep run history in Duckie, so you can review what they researched, which tools they called, and what response they sent.

## Create an Autonomous Agent

<Steps>
  <Step title="Open Agents">
    Go to **Build → Agents** and click **Create Agent**.
  </Step>

  <Step title="Select Autonomous">
    Choose **Autonomous** in the mode selector.
  </Step>

  <Step title="Name the Agent">
    Add a clear name, choose a status, and optionally adjust the model settings.
  </Step>

  <Step title="Write Instructions">
    Describe the agent's job, scope, decision rules, and handoff expectations.

    Good instructions tell the agent what it is responsible for, what it should avoid, and how it should decide between available resources.
  </Step>

  <Step title="Configure Access">
    Open the configuration sections to choose tools, knowledge tags, rules, tracking, runbooks, and workflows.
  </Step>

  <Step title="Save and Test">
    Save the agent, then test it in the [playground](/testing/playground) before deploying it to customers.
  </Step>
</Steps>

## Configuration Reference

### Instructions

Instructions are the primary behavior definition for an autonomous agent.

Use them to define:

* The agent's role and scope
* When to research before answering
* Which situations require escalation
* How to choose between runbooks, workflows, and tools
* Tone or format requirements that are specific to this agent

Example:

```text theme={null}
You are a billing support agent. Help customers understand invoices, payment failures, refunds, and plan changes.

Always check relevant billing runbooks before answering. If a customer asks for a refund, verify eligibility before making promises. Escalate disputes, chargebacks, legal threats, and account ownership questions.
```

### Model

Autonomous agents have model settings in the agent editor. Use the default model for most agents, and increase reasoning effort only when the agent needs deeper analysis.

### Tools

Autonomous agents can use enabled tools from the agent's **Tools** section.

Tool access can include:

* [Duckie Tools](/tools/duckie-tools)
* [App Tools](/tools/app-tools)
* [Custom Tools](/tools/custom-tools)
* [MCP tools](/tools/mcp-servers)

If all available tools are selected, Duckie stores that as all tools enabled. If you select a smaller set, the autonomous agent can only call the selected tools.

### Callable Agents

Use **Callable agents** to control which other agents an autonomous agent can invoke as sub-agents.

| Setting         | Behavior                                                          |
| --------------- | ----------------------------------------------------------------- |
| None            | Agent cannot call other agents                                    |
| All             | Agent can call any active agent in the organization except itself |
| Specific agents | Agent can only call the selected agents                           |

When a callable agent is available, Duckie presents it to the autonomous agent by name and description. The autonomous agent sends a task and chooses whether the child run should include the current conversation history.

[Learn more about sub-agents ->](/agents/sub-agents)

### Knowledge

Use **Knowledge Tags** to limit which knowledge the agent can search.

| Setting                   | Behavior                                   |
| ------------------------- | ------------------------------------------ |
| No tags selected          | Agent can access all knowledge             |
| One or more tags selected | Agent can access knowledge with those tags |
| No Tags selected          | Agent can access untagged knowledge only   |

### Rules

Use **Guidelines** for communication behavior and **Guardrails** for restrictions and escalation rules.

If you do not select specific guidelines or guardrails, the agent can use all available rules for the organization.

### Runbooks and Workflows

Autonomous agents can use runbooks and workflows as resources.

| Setting                    | Behavior                                  |
| -------------------------- | ----------------------------------------- |
| Only allow these runbooks  | Limits which runbooks the agent can read  |
| Block these runbooks       | Hides specific runbooks from the agent    |
| Only allow these workflows | Limits which workflows the agent can call |
| Block these workflows      | Hides specific workflows from the agent   |

Runbooks are the highest-priority procedural resource. If a relevant runbook exists, the autonomous agent is expected to read it before searching broader knowledge.

### Tracking

Use **Attributes**, **Categories**, and **Resolution Tracking** to control how completed runs are classified for analytics.

## Best Practices

* Give the agent a clear job boundary.
* Make escalation conditions explicit.
* Keep powerful write actions limited to agents that need them.
* Use runbook and workflow allowlists for specialized agents.
* Test common, edge-case, and escalation scenarios in the playground.
* Start deployments in testing mode before switching to live traffic.

## Next Steps

<CardGroup cols={2}>
  <Card title="Workflows" icon="diagram-project" href="/workflows/overview">
    Build deterministic flows autonomous agents can call
  </Card>

  <Card title="Sub-Agents" icon="diagram-project" href="/agents/sub-agents">
    Delegate work to other agents
  </Card>

  <Card title="Runbooks" icon="book-open" href="/runbooks/overview">
    Write procedures autonomous agents can read
  </Card>

  <Card title="Tools" icon="wrench" href="/tools/overview">
    Configure actions the agent can take
  </Card>

  <Card title="Playground" icon="flask" href="/testing/playground">
    Test the agent before deployment
  </Card>
</CardGroup>