# Circuits as graphs

> A circuit is a running participant: a party occupying a position, discharging commitments by appending events. Seen as a graph, a circuit is the path from what it observes, through the powers and obligations addressed to its position, to the acts it may validly append, and to whoever inherits the work when it can't.

Canonical: https://endoskeletal.com/circuits/
Last updated: 2026-09-28

## The scaling circuit in Meridian

**Diagram: Graph of the Meridian scaling circuit.**

Nodes:

- Claims `pv.utilization`, `pv.demand`, `pv.price` (from the monitor and bills, status T).
- Position **OpsController** (eligible: `ag.Program`).
- Power **ScaleEnvelope**: authorize execute `pv.Scale` when n ≤ 40 and price × n ≤ 24,000 USD per month.
- External event **execute pv.Scale(n)** via the bound Compute realization.
- Event **misfire recorded**, then propose `pv.ScaleRequest`.
- Obligation **EnvelopeFinding**: 3 requests in 30 days → propose widening the envelope (amendment route → Compiler → envelope v2).
- Position **OpsLead** (eligible: `pp.Person`).
- Obligation **ScaleApproval.Duty**: a commitment to decide within 1 business day.
- Obligation **ScaleApproval.Escalation**: on violation the Owner decides.

Edges: claims → OpsController (reads); OpsController → ScaleEnvelope (acts under); ScaleEnvelope → execute (condition T: valid); ScaleEnvelope → misfire (condition F or N); misfire → EnvelopeFinding (counted); misfire → ScaleApproval.Duty (detaches a commitment); OpsLead → Duty (debtor); Duty → Escalation (or-else); Duty → execute (decide(approve) authorizes the execute).

*One circuit, read from the definitions and the log. Solid accent edges are valid authorization paths; the dashed red edge is where an act without authority lands.*

Reading it: the controller reads utilization, demand and price claims; it acts under the envelope; if the envelope's condition holds, its `authorize` is valid and the `execute` goes through the bound Compute realization. If the condition is false *or unknown* (say, the provider's new price hasn't been confirmed by a bill), the act misfires, the controller proposes a scale request, and `ScaleApproval` detaches a commitment on the OpsLead. A violated commitment escalates to the Owner. Three requests in 30 days oblige the controller to propose widening its own envelope, which it can't do itself.

Reference run: 47 authorize attempts under the envelope, 44 valid; 22 scale requests; 5 envelope widenings materialized.

## Node and edge types

| Node | From | Edges it has |
| --- | --- | --- |
| Position | IR-D; occupancy from appointments | *debtor of* commitments, *bearer of* norms, *incompatible with* |
| Power | IR-D (norm, deontic P) | *covers* an act type, *conditioned on* claims, *constrained by* immunities |
| Obligation → commitment | IR-D norm; commitment detached at runtime | *detached by* an event, *fulfilled by* / *violated at*, *or-else* to the next norm |
| Claim | the log | *supports*, *attacks*, *derivedFrom*, *read by* a condition |
| Event | the log | *under* a power, *authorizedBy* an institutional act, *via* a realization |
| Realization | binds in the log | *realizes* a requirement, *offered by* a party, *grounded in* adapters |

A graph view is always a projection at an index: edges appear when a norm is enacted or a commitment detaches, and disappear when a norm is repealed, a commitment closes or a realization is unbound. Scrubbing the index animates the organization.

## Process falls out

There's no process primitive. Sequence is a chain of response norms; parallel work is independent commitments detached by the same event; synchronization is a power whose condition needs several claims to hold; escalation and compensation are or-else norms on a different bearer. The workflow you'd draw in BPMN is the observed trace through this graph, which means partial compliance, deviation and rule changes mid-flight are all representable.