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

# Deliverables

Deliverables are the results a job produces: each is one record of shipped (or in-progress) work, priced from the job's deliverable types and billed on the organization's monthly statement. How a deliverable moves from creation to shipped is described in [Deliverable Lifecycle](/docs/how-membrane-works/deliverables/lifecycle).

They have the following properties:

| Property     | Description                                                                                                                                                        |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `id`         | Unique identifier of the deliverable.                                                                                                                              |
| `jobId`      | The job this deliverable belongs to.                                                                                                                               |
| `typeId`     | The [deliverable type](#deliverable-types) this is an instance of — where its pricing and autonomy come from.                                                      |
| `taskId`     | The task whose execution produced it. The task's conversation is where the operator talks to the agent about it.                                                   |
| `title`      | What this deliverable is, in one line — "COGS report — July 2026".                                                                                                 |
| `summary`    | Markdown. What was done, written for the customer — this is the text that ships with the result.                                                                   |
| `reviewNote` | Markdown. The agent's note to the operator: what to check, what it was unsure about, with links to the underlying artifacts. Shown during review; never delivered. |
| `status`     | `pending`, `review`, `approved`, `shipped`, or `voided` — see the [lifecycle](/docs/how-membrane-works/deliverables/lifecycle).                                    |
| `lineItems`  | The resolved price lines; the deliverable's price is their sum. See [line items](#line-items).                                                                     |
| `links`      | Standard element links to the work products behind the result — a canvas with the draft, a data table with the records, a connector.                               |
| `createdAt`  | When the record was created.                                                                                                                                       |
| `approvedAt` | When the operator approved it. Absent for pre-approved work that never went through review.                                                                        |
| `shippedAt`  | When the agent marked it delivered.                                                                                                                                |
| `billedAt`   | When the monthly statement containing it was billed. Absent while the deliverable sits on the current open statement.                                              |

### Line items

Each entry of `lineItems` is one priced line:

| Property      | Description                                                                          |
| ------------- | ------------------------------------------------------------------------------------ |
| `label`       | What the line is for — "Build new connector", "Customer request handled".            |
| `amountCents` | The line total, in cents. `0` for included (free) work.                              |
| `quantity`    | Optional unit count for per-unit pricing; the label renders with it ("× 40").        |
| `menuKey`     | For menu-priced types — the `key` of the [menu entry](#pricing) this line came from. |

## Deliverable types

A deliverable type is a price-list entry on the job: one kind of result the job produces, agreed at setup.

| Property      | Description                                                                                                                   |
| ------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `id`          | Unique identifier of the type.                                                                                                |
| `jobId`       | The job the type is configured on.                                                                                            |
| `name`        | What the job ships — "Monthly COGS report", "Customer request handled".                                                       |
| `description` | What's included, in a sentence.                                                                                               |
| `pricing`     | How deliverables of this type are priced. See [pricing](#pricing).                                                            |
| `autonomy`    | `needs-approval` — the operator approves each deliverable before it ships; `pre-approved` — agreed at setup, ships when done. |

### Pricing

`pricing` is a discriminated union on `kind`:

| Kind       | Shape                                           | Meaning                                                                                                                                                                                                                                                                                             |
| ---------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fixed`    | `{ kind, amountCents }`                         | Every deliverable of this type bills the same amount — a monthly close at \$900.                                                                                                                                                                                                                    |
| `per-unit` | `{ kind, unitAmountCents, unitNoun }`           | Priced per unit **within** a deliverable: the line item's `quantity` multiplies `unitAmountCents`. Use when one deliverable covers a countable batch (per record imported, per document processed). A type where every deliverable is exactly one unit behaves like `fixed` — prefer `fixed` there. |
| `menu`     | `{ kind, menu: [{ key, label, amountCents }] }` | Every price agreed up front as a menu of named entries; each deliverable picks the entries the work turned out to require, as line items carrying the `menuKey`.                                                                                                                                    |
| `free`     | `{ kind }`                                      | Included with the job — shipped and recorded, never billed.                                                                                                                                                                                                                                         |

## Task grants

Which deliverable types a task can produce is declared on its routine:

| Property    | Description                                                                                                                                   |
| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `typeId`    | The deliverable type the task may produce.                                                                                                    |
| `automatic` | The deliverable is created by Membrane when the task starts, and the task works against that record — e.g. one per incoming customer request. |