The manager

Standard interface · name interface-manager · v0.2.0-draft · 2026-08-29 · portable

What a worker can rely on from whatever is directing it. The other side of the worker interface. Four exchanges: here is work, here is your answer, stop that, and what did you commit.

Anything that directs a worker implements this, including a person's script. It is not a job and holding it is not a role.

1. Why this exists

An interface with only one side published is half a contract. A worker that answers all seven of its exchanges faithfully can still be stranded: handed a job with no statement of what counts as done, raising a block that nobody answers, or working for an hour on something cancelled upstream.

Three of the four exchanges here face the worker. The fourth faces the owner, and it is the reason this is publishable at all. Something that can commit on your behalf without being answerable for it is not something you should run.

An agent that manages a fleet on an owner's behalf is a job rather than a slice of behaviour, and the registry expects to publish that as a role. The role would implement this interface. Nothing here waits on it.

2. The exchanges

  1. Here is work. A job carries what is wanted, what counts as done, and every constraint already agreed with somebody else that limits how it may be done. A worker cannot honour a promise it was never told about.
  2. Here is your answer. When a worker raises a block, the manager answers it. "I cannot clear this, refuse the job" is an answer. Not answering is the failure.
  3. Stop that. Telling a worker its job is no longer wanted. Work cancelled upstream and still running is spending somebody's money on nothing.
  4. What did you commit? Asked by its owner: what it agreed on the owner's behalf, and which worker it gave the work to. The one exchange facing the owner rather than the worker.

3. The contract

  1. Terms flow down. Every constraint already agreed that bears on how the work is done is passed on, including where the work may be performed and what may be kept afterwards. A constraint that stops at the manager is a promise nobody is keeping.
  2. It does not assign work whose terms the worker cannot meet. Checking is the manager's job, and it happens before the assignment rather than after the failure.
  3. Capacity is confirmed, not assumed. It never states capacity it has not confirmed by asking. A process list, a schedule, and its own memory of an earlier answer are not asking.
  4. It does not commit beyond the authority it holds. Where it can commit at all, it refuses at its limit rather than at the failure that follows exceeding it.
  5. It answers, or it says it will not. A raised block draws an answer within a stated time, or a statement that none is coming.
  6. Cancellation reaches the worker. A manager that learns work is no longer wanted tells whoever is doing it.
  7. It does not hide what it committed. The fourth exchange is not optional and is never answered selectively.
  8. No document. Like the worker, this interface defines no signed statement. What a manager committed on an owner's behalf is worth signing, and the registry expects the role holding this interface to define that statement. An interface says how two parties talk. What gets signed belongs to the job.

4. Conformance

Behavioural. A harness checks that a job handed down carries the constraints already agreed above it; that a manager whose only available worker cannot meet those constraints declines to assign rather than assigning and hoping; that a raised block draws an answer or an explicit refusal to answer, and never silence; that cancelling work upstream produces a stop downstream; that a request to commit beyond its authority is refused at the limit; and that asked what it committed, it says, in full.

v0.2.0-draft (2026-08-29): first draft, published with the worker interface. Rules 1 and 3 are the ones to argue with. The first is what stops an agreement made at the top from quietly not applying at the bottom, which is the failure mode of every arrangement where one party promises and another performs. The third is written against a specific lesson: a process reporting itself as running is not an agent reporting itself as able to answer, and a manager that confuses the two will quote turnarounds it cannot hit.