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

# Managing Agents

Agents are the workflows your team has built in Duvo. The CLI lets you list, inspect, create, and update Agents, organize them into folders, and manage their Revisions (versioned Setup snapshots).

## Listing and inspecting Agents

```bash theme={"dark"}
duvo agents list                        # list all Agents
duvo agents get <agent-id>              # get a specific Agent
```

Add `--json` to any command for machine-readable output.

## Creating, updating, and deleting Agents

```bash theme={"dark"}
duvo agents create \
  --name "Invoice Processor" \
  --input "Process incoming invoices…" \
  --config path/to/config.json
# --input is optional (AOP text); --config is optional (full Setup)

duvo agents update <agent-id> \
  --name "New Name" \
  --enable-slack \
  --enable-microsoft-teams \
  --enable-agentic-memory
# --name renames the Agent
# --enable-slack / --enable-microsoft-teams toggle delivery (--disable-* to turn off)
# --enable-agentic-memory toggles agentic memory (--disable-agentic-memory to turn off)

duvo agents delete <agent-id>           # delete an Agent (prompts for confirmation)
duvo agents delete <agent-id> --yes     # delete without prompting
```

## Starting Runs automatically

Agents can start Runs on their own — on a schedule, when an external event fires, or when a Case lands on a Queue. These live on their own page: see [Scheduling and Triggers](/cli/scheduling-and-triggers) for `duvo agents schedules`, `duvo agents triggers`, and `duvo agents case-triggers`.

## Organizing with folders

Group Agents into folders for easier navigation.

```bash theme={"dark"}
duvo agent-folders list                              # list all folders
duvo agent-folders create --name "Finance"           # create a top-level folder
duvo agent-folders create --name "EMEA" \
  --parent <folder-id>                               # create a nested folder
duvo agent-folders update <id> --name "New Name"    # rename a folder
duvo agent-folders update <id> --parent <id>        # move folder under a parent
duvo agent-folders update <id> --move-to-root       # move folder to root level
duvo agent-folders delete <id>                      # delete a folder (prompts for confirmation)
duvo agent-folders delete <id> --yes                # delete without prompting
duvo agent-folders move-agents \
  --agent <id> --agent <id> \
  --folder <folder-id>                              # move Agents into a folder
duvo agent-folders move-agents \
  --agent <id> \
  --to-root                                         # move Agent to root level
```

## Revisions

A Revision is a versioned Setup snapshot of an Agent. Each time you publish changes, a new Revision is created. Most workflows don't need to manage Revisions directly — Runs always use the latest Revision automatically. Use these commands when you need to roll back, compare versions, or update a specific Revision in place.

```bash theme={"dark"}
duvo revisions list --agent <agent-id>                  # list all Revisions
duvo revisions get <revision-id> --agent <agent-id>     # get a specific Revision
duvo revisions create \
  --agent <agent-id> \
  --name "v2" \
  --config-file path/to/config.json                     # use `-` to read Setup from stdin
duvo revisions update <revision-id> \
  --config-file path/to/config.json                     # update an existing Revision's Setup
```

## Memory

When an Agent has agentic memory enabled, it persists notes across Runs as memory files. Use these read-only commands to see what an Agent has remembered.

```bash theme={"dark"}
duvo agents memory files <agent-id>             # list the memory files stored for an Agent
duvo agents memory file-get <agent-id> <path>   # print the contents of one memory file
```

Toggle agentic memory itself with `duvo agents update <agent-id> --enable-agentic-memory` / `--disable-agentic-memory`.

## Evaluation rubrics

Every Run is scored against evaluation rubrics: the platform default rubrics plus up to five custom, Agent-specific rubrics per Revision. Custom rubrics are Pass/Fail checks written as a short title and a Pass condition. Use these commands to read and manage the custom set.

```bash theme={"dark"}
duvo agents eval-rubrics <agent-id>                      # list active rubrics (platform + custom)

duvo agents eval-rubrics add <agent-id> \
  --title "Cited every source" \
  --description "The reply links a source URL for each claim"
# add one custom rubric — fails once the Revision already holds 5

duvo agents eval-rubrics update <agent-id> <rubric-id> \
  --title "New title"
# edit a rubric's title and/or description (pass at least one)

duvo agents eval-rubrics remove <agent-id> <rubric-id>         # remove a rubric (prompts for confirmation)
duvo agents eval-rubrics remove <agent-id> <rubric-id> --yes   # remove without prompting

# Replace the whole custom set from a JSON array of { "title", "description" } objects
# (use "-" to read from stdin); an empty array clears the set.
# This replaces every existing rubric, so it prompts for confirmation:
duvo agents eval-rubrics replace <agent-id> --input rubrics.json
duvo agents eval-rubrics replace <agent-id> --input rubrics.json --yes   # replace without prompting
```

Add `--json` to any command for machine-readable output. These default to the Agent's live Revision; pass `--build <build-id>` to read or edit the set on a specific Revision.

## Scripting examples

### Create an Agent from a JSON config

```bash theme={"dark"}
AGENT_ID=$(duvo agents create \
  --name "Invoice Processor" \
  --config-file ./invoice-processor.json \
  --json | jq -r '.agent.id')

echo "Created Agent: $AGENT_ID"
```

### Roll out a config change across multiple Agents

```bash theme={"dark"}
for AGENT in agent-1 agent-2 agent-3; do
  duvo revisions create \
    --agent "$AGENT" \
    --name "memory-enabled-$(date +%Y%m%d)" \
    --config-file ./shared-config.json
done
```

For commands that bind specific Connections or integrations to a Revision, see [Advanced commands](/cli/advanced).
