Introduction

In CVAT, a task is the top-level annotation unit, and jobs are the chunks of work assigned inside that task. If you want multiple annotators to work in parallel, the usual approach is to create one task and split its data into multiple jobs by choosing an appropriate segment size.

How Tasks and Jobs Relate in CVAT

A task contains the source data, labels, and annotation settings. CVAT then divides that task into jobs so work can be distributed. For an image task, that usually means a set of frames or files per job. For a video task, it means frame ranges.

The key point is that jobs are generally derived from task settings rather than created as unrelated standalone items later. If you upload 1,000 images and choose a segment size of 100, CVAT can produce 10 jobs from the same task.

That makes review easier because:

• labels stay centralized in one task,
• annotators can be assigned separate jobs,
• progress can be tracked in one place,
• consensus and QA are easier than splitting everything into unrelated tasks.

Creating Multiple Jobs from the UI

The most common workflow is during task creation.

1. Open CVAT and create a new task.
2. Enter the task name and labels.
3. Upload images or a video.
4. Set the segment size.
5. Create the task.

The segment size controls how much data goes into each job. For example, if you upload 500 images and use a segment size of 50, the task is divided into 10 jobs.

A practical rule is to make jobs small enough that one annotator can finish a job in a reasonable session, but not so small that management overhead becomes the main cost.

For example:

• 20 to 100 images per job works well for detailed image labeling.
• Larger jobs may be fine for quick classification.
• Video jobs often need overlap so objects crossing segment boundaries are easier to handle.

Example Through the API

If you create tasks through automation around CVAT, the same idea applies. You create one task and choose the segmentation settings up front.

1import os
2import requests
3
4base_url = os.environ["CVAT_URL"].rstrip("/")
5token = os.environ["CVAT_TOKEN"]
6
7headers = {
8    "Authorization": f"Token {token}",
9}
10
11payload = {
12    "name": "warehouse-camera-batch-01",
13    "labels": [
14        {"name": "box"},
15        {"name": "forklift"},
16    ],
17    "segment_size": 100,
18    "overlap": 0,
19}
20
21response = requests.post(
22    f"{base_url}/api/tasks",
23    json=payload,
24    headers=headers,
25    timeout=30,
26)
27response.raise_for_status()
28print(response.json()["id"])

That request creates the task definition. In a real workflow, you would then upload the data to the task. The important detail is that segment_size is what causes CVAT to create multiple jobs within the same task.

Choosing a Good Segment Size

There is no single correct number. Pick a size based on annotation difficulty and reviewer workflow.

Smaller jobs help when:

• many annotators are working in parallel,
• review must happen continuously,
• the dataset contains hard edge cases,
• jobs need to be reassigned frequently.

Larger jobs help when:

• setup overhead is high,
• the task is simple and repetitive,
• context across nearby frames matters,
• the same annotator should keep ownership of a long sequence.

For video, overlap matters almost as much as segment size. Without overlap, an object near a job boundary can be inconvenient to annotate and review.

When You Need to Repartition a Task

A common question is whether you can freely create extra jobs later from an already-created task. In practice, CVAT workflows are easiest when you get segmentation right at task creation time. If the original segment size was a poor choice, many teams simply recreate the task with better settings rather than force an awkward split later.

That is especially true when:

• one job is too large for a single reviewer,
• annotators need a more even workload,
• overlap was omitted for video,
• the source data ordering should be changed.

Common Pitfalls

The biggest mistake is treating tasks and jobs as independent planning units. In CVAT, jobs come from task segmentation, so the fix is usually to adjust segment_size and overlap when creating the task.

Another problem is choosing a tiny segment size, such as five images, for a large project. That creates too many jobs and increases assignment, review, and status-tracking overhead. If your team spends more time moving jobs around than annotating, the split is too fine.

For video tasks, forgetting overlap can create awkward boundary cases. Add overlap when adjacent frames need continuity.

Summary

• In CVAT, multiple jobs are usually created by splitting one task into segments.
• The main control is segment_size, with overlap especially important for video.
• One task with many jobs is often better than many separate tasks.
• Choose job size based on annotation difficulty, review flow, and team size.
• If segmentation is wrong, recreating the task with better settings is often the cleanest fix.