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

# Workflow v3.stages

Stage types in a read-only workflow graph snapshot.

## Stage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class Stage(Generic[SettingsT, TaskT])
```

Identity and outgoing connections for one stage in the loaded graph.

#### get\_tasks

```python theme={"dark"}
def get_tasks(*,
              statuses: Optional[Sequence[TaskStatus]] = None,
              sort: Optional[TaskSort] = None) -> Iterator[TaskT]
```

Iterate permitted current tasks, fetching pages lazily without assigning work.

Invalid status and sort values are rejected immediately. Backend validation
and request errors occur during iteration. This is a changing queue, not
a snapshot. Terminal stages use newest-arrival ordering and reject both
statuses and sort arguments.

## StartStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class StartStage(Stage[Union[StartStageSettingsV1, UnknownStageSettings],
                       Task])
```

Background processing at workflow entry.

## AnnotationStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class AnnotationStage(Stage[Union[AnnotationStageSettingsV1,
                                  UnknownStageSettings], AnnotationTask])
```

Manual annotation of targets.

#### submit\_tasks

```python theme={"dark"}
def submit_tasks(tasks: Sequence[AnnotationTask],
                 *,
                 pathway_id: Optional[Union[UUID, str]] = None,
                 pathway_name: Optional[str] = None,
                 comment: Optional[str] = None) -> None
```

Submit Annotation tasks at this stage atomically; save labels separately first.

Pathway selection, comments and permissions follow AnnotationTask.submit().
One pathway and optional comment apply to every task. Empty batches raise
ValueError; the backend enforces batch limits. Leaves snapshots unchanged;
sent requests are not automatically retried.

## ReviewStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class ReviewStage(Stage[Union[ReviewStageSettingsV1, UnknownStageSettings],
                        ReviewTask])
```

Manual review of targets and labels.

#### submit\_tasks

```python theme={"dark"}
def submit_tasks(tasks: Sequence[ReviewTask],
                 *,
                 pathway_id: Optional[Union[UUID, str]] = None,
                 pathway_name: Optional[str] = None,
                 comment: Optional[str] = None) -> None
```

Submit tasks atomically without changing individual label decisions.

Tasks must be at this stage. Pathway selection, comments and permissions
follow ReviewTask.submit(). One pathway and optional comment apply to every
task. Empty batches raise ValueError; the backend enforces batch limits.
Leaves snapshots unchanged; sent requests are not automatically retried.

## ExternalStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class ExternalStage(Stage[Union[ExternalStageSettingsV1, UnknownStageSettings],
                          ExternalTask])
```

Work held for an external integration.

#### submit\_tasks

```python theme={"dark"}
def submit_tasks(tasks: Sequence[ExternalTask],
                 *,
                 pathway_id: Optional[Union[UUID, str]] = None,
                 pathway_name: Optional[str] = None) -> None
```

Submit External tasks at this stage atomically through one pathway.

Pathway selection and permissions follow ExternalTask.submit(). Empty
batches raise ValueError; the backend enforces batch limits.
Leaves snapshots unchanged; sent requests are not automatically retried.

## CompleteStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class CompleteStage(Stage[Union[CompleteStageSettingsV1, UnknownStageSettings],
                          Task])
```

Terminal stage for the Complete outcome.

## ArchiveStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class ArchiveStage(Stage[Union[ArchiveStageSettingsV1, UnknownStageSettings],
                         Task])
```

Terminal stage for the Archive outcome.

## SkipStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class SkipStage(Stage[Union[SkipStageSettingsV1, UnknownStageSettings], Task])
```

Terminal stage for the Skip outcome.

## PercentageRouterStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class PercentageRouterStage(Stage[Union[PercentageRouterStageSettingsV1,
                                        UnknownStageSettings], Task])
```

Targets are routed by the configured pathway allocations.

## CollaboratorRouterStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class CollaboratorRouterStage(Stage[Union[CollaboratorRouterStageSettingsV1,
                                          UnknownStageSettings], Task])
```

Route targets using the user who last processed them at a manual stage.

## UnknownStage Objects

```python theme={"dark"}
@dataclass(frozen=True, repr=False)
class UnknownStage(Stage[UnknownStageSettings, Task])
```

An unfamiliar stage available for discovery, not specialized operations.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.