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

# Overview

> A Harbor task is an instruction, environment, and test script.

A Harbor task is an instruction, environment, and test script. The task is defined as a directory of files with the following structure:

```bash theme={"system"}
instruction.md
task.toml
environment/
├── Dockerfile  # or some other spec
└── ...
solution/
├── solve.sh
└── ...
tests/
├── test.sh
└── ...
```

Environments can be defined using any spec, as long as the consumer of the task (e.g. Harbor framework) supports it. Popular specs include `Dockerfile`, `docker-compose.yaml` (for multi-container environments), and `Apptainer.def` (for HPCs).

## Trials

A Harbor trial is an agent's attempt at completing a task. The diagram below shows how the components of a task are used in a trial.

```mermaid theme={"system"}
%%{init: {"flowchart": {"curve": "basis", "nodeSpacing": 60, "rankSpacing": 70}, "look": "handDrawn"}}%%
flowchart LR
  Task(Task) --> Start((Start<br/>Environment))
  Start --> C1((Environment))
  C1 --> C2((Environment))
  C2 --> Stop((Stop<br/>Environment))

  C1 --> Agent((Agent))
  Agent --> C1
  Agent --> Trajectory[/Trajectory/]
  C2 --> Verifier((Verifier))
  Verifier --> C2
  Verifier --> Reward{Reward}
  Reward --> Evals[Aggregate<br/>across eval]
```

## Rewards

A task defines the logic to verify the completion of the instruction and produce a reward in the `tests/test.sh` script. The script must produce a numerical reward in the environment at `/logs/verifier/reward.txt` or `/logs/verifier/reward.json` (for multi-dimensional or labeled rewards).

## Independent, isolated, and reproducible

Harbor tasks are independent, isolated, reproducible pieces of code. Harbor tasks have no dependency on the Harbor framework. They can easily be plugged into any framework that supports the Harbor format. However, the Harbor framework is a simple way to start running tasks at scale.

Think of tasks like software packages that should be self-contained, verisioned, maintained, and developed over time.

## Task components

* [`instruction.md`](/core-concepts/tasks/instruction)
* [`task.toml`](/core-concepts/tasks/configuration)
* [`environment/`](/core-concepts/tasks/environment)
* [`solution/`](/core-concepts/tasks/solution)
* [`tests/`](/core-concepts/tasks/verifier)

## Multi-step tasks

Harbor tasks can be split into multiple steps, each with its own instruction, tests, and solution. Multi-step tasks are great for defining milestones in long-horizon tasks, testing continual learning methods like memory, and observing an agent's ability to build on its prior work.

See [multi-step tasks](/core-concepts/tasks/multi-step) for a detailed overview.

```bash theme={"system"}
task.toml
environment/
├── Dockerfile  # or some other spec
└── ...
tests/
├── test.sh  # optional shared helpers
└── ...
steps/
├── step-1/
│   ├── instruction.md
│   ├── tests/
│   │   ├── test.sh
│   │   └── ...
│   ├── solution/
│   │   ├── solve.sh
│   │   └── ...
│   └── workdir/
│       ├── setup.sh  # optional
│       └── ...
└── step-2/
    └── ...
```