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

# Delegation

> Delegated authority subdivides and never multiplies. The API refuses to issue a grant that exceeds its parent, and spend debits every ancestor.

Multi-agent pipelines hand authority downward. Almost every implementation
copies the parent's permissions to the child instead of subdividing them, so a
pipeline of five agents each holding a £10,000 limit is a pipeline with a
£50,000 limit that nobody agreed to.

Two properties stop that, and both are enforced rather than documented.

## Attenuation is refused, not warned about

A delegated grant may be **narrower** than its parent on every dimension and
wider on none: scope, window, budget, conditions, enforcement mode.

```http theme={"system"}
POST /v1/grants/{grant_id}/delegate
```

The API refuses to issue one that exceeds its parent. Not a warning, not a lint
rule, not a line in a design document. The call fails and the pipeline does not
start, so an engineer finds out at development time rather than an auditor
finding out at quarter end.

<Warning>
  A constraint that can be worked around under deadline pressure is not a
  constraint, it is a preference. This is why it lives in the issuer rather than
  in review.
</Warning>

A parent must opt in by setting `delegation_policy: "attenuating"`. The default
is `none`, which means an agent cannot delegate at all. Authority to hand
authority onward is itself an authority.

## Spend debits every ancestor

Attenuation alone is not enough. Give every child £5,000 under a £25,000 parent
and ten children still spend £50,000.

So when a leaf spends, the debit lands on the leaf **and on every grant above it
to the root**. Two things follow:

* **The root's ceiling is the tree's ceiling.** However the work is divided, the
  total is bounded by what the accountable human signed for.
* **An exhausted ancestor refuses a child that still has room.** This looks
  wrong the first time an engineer sees it and is exactly right. The child's own
  allowance was never the operative limit.

## Revocation reaches down

Revoking a parent revokes its children. The part usually skipped is the
interval: between the revoke and the last child stopping there is a window, and
actions may have been permitted in it. "We revoked at 14:02" is not an answer to
"what did it do at 14:03". The record answers it.

## Recording a delegation in the trajectory

Delegation is also a step worth recording even where no new grant is minted, so
the trajectory shows the handoff:

```python theme={"system"}
with rs.agent("claims-orchestrator").trajectory(claim="CLM-4003") as t:
    t.delegation(agent="claims-adjuster", reason="quantum assessment")
```

## Next

<Card title="Delegate authority" icon="sitemap" href="/guides/delegate-authority">
  The call, and what to check afterwards.
</Card>