> ## 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.

# Operator Contracts

When a job is operated by someone outside your organization, the terms are agreed in a **contract**: one record of one job↔operator relationship — what the job does, what its results cost, and who operates it. Nothing starts and nothing changes without both sides having seen and accepted it.

Jobs you operate yourself, or hand to someone in your own organization, don't involve contracts — you assign the operator directly and edits take effect immediately.

## What a contract carries

* **What the job does** — the scope the operator commits to deliver.
* **The price list** — the kinds of [deliverables](/docs/how-membrane-works/deliverables) the job produces and what each costs. The list is adopted from the job when the contract is drafted; while an agreement is in effect, it's part of the terms and changes only by agreeing on a new version.

Routines are deliberately not part of the terms: they are how the operator runs the job, and can change without re-approval. You agree on what is delivered and at what price — not on the operator's methods.

## The lifecycle

```mermaid theme={null}
stateDiagram-v2
    direction LR
    [*] --> Draft: drafted
    Draft --> Proposed: send
    Proposed --> Draft: decline / withdraw
    Proposed --> Active: accept
    Active --> Ended: end, or superseded
    Ended --> [*]
```

One flow covers everything: the first agreement on a job, a change to a live agreement, a handover to a different operator, and re-engaging after an agreement ended. In every case, the operator drafts and sends a contract, and the client accepts or declines.

### Draft

Being written by the operator, usually with the agent's help. Both parties can see the draft, while only the operator can edit and send it. A declined or withdrawn proposal also returns here, ready to be revised and re-sent.

**Gets here by:** being drafted, or coming back from a declined or withdrawn proposal.

| What can happen   | Who          | What happens next                                     |
| ----------------- | ------------ | ----------------------------------------------------- |
| Edit the terms    | The operator | —                                                     |
| Send the proposal | The operator | The terms freeze and the decision moves to the client |
| Delete the draft  | The operator | The contract is discarded                             |

### Proposed

An offer on the table: sending it puts a review item in the client's Inbox, and their decision — accepted or declined — lands back in the operator's. The terms are frozen — the client decides on exactly what was sent, and nobody can change it under them. To change anything, the operator withdraws it, edits the draft, and sends it again; when they do, the new proposal shows what changed since the version the client last saw. Counter-offers aren't made by editing — they happen in the job's conversation, and the operator revises.

A job can have several proposals out at once — for example, terms sent to two candidate operators. The first acceptance wins; the others are withdrawn automatically, with a note to each.

**Gets here by:** the operator sending it.

| What can happen | Who          | What happens next                                            |
| --------------- | ------------ | ------------------------------------------------------------ |
| Accept          | The client   | The contract becomes the job's agreement (see below)         |
| Decline         | The client   | Back to the operator as an editable draft — comments welcome |
| Withdraw        | The operator | Back to draft for revision                                   |

### Active

The agreement the job runs under, numbered for its place in the job's history — Agreement v1, v2, v3. Accepting did three things at once: the operator took the job, any previous agreement was superseded (the job switches over with no gap), and the job's other open proposals were withdrawn.

The terms are now fixed for both sides. Changing them means the operator proposes a new version from the current contract, and the job keeps running on the current terms until the client accepts. Changes apply going forward — results already delivered keep the price they were delivered under.

**Gets here by:** the client accepting the proposal.

| What can happen   | Who          | What happens next                                                 |
| ----------------- | ------------ | ----------------------------------------------------------------- |
| Propose changes   | The operator | A new contract, drafted from this one, goes through the same flow |
| End the agreement | Either side  | The agreement ends — see below                                    |

### Ended

The relationship is over — either because one side ended it, or because a newer agreement superseded it. Ending is unilateral: no approval from the other side, no notice period. Everything the job produced under this agreement — deliverables, statements, the conversation — stays readable.

An agreement ending (other than by being superseded) clears the job's operator, so the job stops running. It isn't gone: take it over yourself, assign someone from your organization, or agree with an operator again — the same flow as the first time.

**Gets here by:** either side ending it, or a newer agreement being accepted in its place.

Nothing more happens to an ended contract.

## No surprises

The flow is built so neither side is ever bound to something they haven't seen:

* Nothing runs until someone has explicitly taken the job — accepted its terms, or said "I'll operate this job."
* The side reviewing a proposal decides on exactly what was sent — proposals can't change once sent.
* A live job never changes terms silently: it runs on the current agreement until the new one is accepted.
* Ending is always available to both sides, and everything already produced stays on the record.