# Managing Assignments

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

## Listing and inspecting Assignments

```bash
duvo agents list                        # list all Assignments
duvo agents get <agent-id>              # get a specific Assignment
duvo agents schedules <agent-id>        # list schedules for an Assignment
```

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

## Creating and updating Assignments

```bash
duvo agents create \
  --name "Invoice Processor" \
  --input "Process incoming invoices…" \  # optional: include SOP text
  --config path/to/config.json            # optional: include full Setup

duvo agents update <agent-id> \
  --name "New Name" \                     # rename the Assignment
  --enable-slack \                        # enable Slack delivery (--disable-slack to turn off)
  --enable-microsoft-teams \              # enable Teams delivery (--disable-microsoft-teams to turn off)
  --enable-agentic-memory                 # enable agentic memory (--disable-agentic-memory to turn off)
```

## Case triggers

A Case Trigger connects an Assignment to a Queue so it automatically picks up new Cases as they arrive. For background on the Case Queue system, see [Case Queue](https://github.com/duvoai/monorepo/blob/gitbook-prod/knowledge-base/assignment-features/case-queue.md).

```bash
duvo agents case-triggers list <agent-id>                                   # list triggers and their IDs
duvo agents case-triggers get <agent-id> <trigger-id>                       # show details for one trigger
duvo agents case-triggers create <agent-id> --queue <queue-id> --enabled    # create a trigger (omit --enabled to create it disabled)
duvo agents case-triggers update <agent-id> <trigger-id> --enable           # enable an existing trigger
duvo agents case-triggers update <agent-id> <trigger-id> --disable          # disable an existing trigger
duvo agents case-triggers update <agent-id> <trigger-id> \
  --queue <queue-id>                                                        # switch the queue the trigger listens to
duvo agents case-triggers update <agent-id> <trigger-id> --concurrency 5    # cap parallel Jobs for this trigger
duvo agents case-triggers update <agent-id> <trigger-id> --clear-concurrency # remove the concurrency cap
duvo agents case-triggers delete <agent-id> <trigger-id>                    # delete the trigger
duvo agents case-triggers preview <agent-id> --queue <queue-id>             # check whether a queue already has an active trigger
```

Only the person who set up a trigger or a team Builder or admin can disable it or change its queue. Disabled triggers stay attached to the Assignment but stop dispatching new Jobs until re-enabled.

## Organizing with folders

Group Assignments into folders for easier navigation.

```bash
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 Assignments into a folder
duvo agent-folders move-agents \
  --agent <id> \
  --to-root                                         # move Assignment to root level
```

## Revisions

A Revision is a versioned Setup snapshot of an Assignment. Each time you publish changes, a new Revision is created. Most workflows don't need to manage Revisions directly — Jobs 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
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
```

## Scripting examples

### Create an Assignment from a JSON config

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

echo "Created Assignment: $AGENT_ID"
```

### Roll out a config change across multiple Assignments

```bash
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.md).


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.duvo.ai/cli/managing-assignments.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
