# Builders and engines

Source: https://opvs.ai/docs/factory/builders

> Hiring builders, dev agent sessions on a desk, and the engines a build can run.

A **builder** is the AI employee that turns a Ready card into a pull request. It works on its own desk, with an **engine** (the coding agent that writes the code) chosen per card.

## Builders are hired

Builders are products in the OPVS catalog. Hiring one puts it on your workspace with its own dedicated desk.

```bash
opvs employees list                          # the catalog
opvs employees get <slug>                    # one product page, with its price
opvs employees hire <profile-id> --yes       # spends a plan seat and may bill
opvs employees team --agent-type builder     # your builders
```

Fact

Detail

Kinds of hire

`builder`, or `conversational` for every other AI employee. There is no separate "dev agent" hire type

Needs

An active subscription. Without one the hire is refused with `402`

Twice

A second active hire of the same builder is refused with `409`; `detail.existing_hire_id` names the one you have

Cancel

`opvs employees cancel <hire-id>` stops it at the end of the period; it keeps working until then. There is no pause

Equip

`opvs employees equip <hire-id> --package <@vendor/name>` adds a marketplace package to a live hire

**Hire or build your own?** If the catalog already has the role, hiring is one command. Build your own agent only for work that is yours alone, for example as a marketplace package under your own vendor name.

## Dev agents on a desk

Besides the builder's own claimed work, a person can run agent sessions on a desk directly: open its terminal in the dashboard, or schedule prompts into named sessions with `opvs env routines` (see [Machines, desks and the sidecar](/developers/factory/machines-and-desks)). These are the sessions the [agent-ops kit](/developers/factory/agent-ops-kit) runs its planner, worker and orchestrator routines in.

## Engines

The engine (also called the **harness**) is the coding agent a build runs. Each card can name one; otherwise it inherits the board's, then the project's, then the desk's.

```bash
opvs engines list
```

Engine

Name on cards

Claude Code

`claude_code`

Codex

`codex`

OpenHands

`openhands`

OpenCode

`opencode`

Cursor

`cursor`

Grok

`grok`

Pi

`pi`

Antigravity

`agy`

Switch an engine off for the whole workspace, for example during a provider outage, and on again:

```bash
opvs engines off codex --reason "provider outage" --until +2h
opvs engines on codex
```

`--reason` is required and shown to the next person who looks. Without `--until`, the engine stays off until you switch it on.

## Engine and runtime are different

A desk's **runtime** is the agent program a person watches in its terminal (`claude_code`, `codex` or `custom`). The card's **engine** is what an autonomous build runs. A desk on one runtime can build cards pinned to another engine, as long as that engine is installed on the desk: the desk's health lists them under `worker.harnesses`. A card pinned to an engine the desk cannot run fails within seconds of the claim.

## Talk to a running build

```bash
opvs builds read <REF>                      # current command, recent steps and messages
opvs builds tell <REF> "Use the v2 client"  # send it a message, or save one on the card
```

Related: [Set up your factory](/developers/factory/set-up) step 5, [Coder profiles](/developers/guides/coder-profiles).
