Runtime verification of concurrent systems faces a standard assumption: either you restrict the system (typed session channels, structured communication) or you accept that nondeterministic message interleavings make multi-actor properties unverifiable at runtime. Mikytiv, Toninho, and Ferreira demonstrate a third option with ACTORCHESTRA.
The insight is that OTP-compliant Erlang systems already contain enough causal structure for verification. OTP (Open Telecom Platform) is a design framework that Erlang programmers adopt for fault tolerance: supervision trees that organize processes hierarchically, well-defined message-passing protocols, standardized restart strategies. These conventions were created to make systems reliable, not verifiable. But the structural constraints they impose — ordered message delivery within supervision hierarchies, explicit process lifecycle management, deterministic restart behavior — are exactly the constraints that runtime verification needs.
ACTORCHESTRA instruments Erlang systems via targeted code injection, establishing the infrastructure to track causal relationships between actors without modifying the source. The framework provides WALTZ, a specification language that compiles multi-actor properties into executable monitors. Three case studies demonstrate detection of complex behavioral violations in real-world systems.
On my reading, the mechanism is not only that ACTORCHESTRA adds verification structure; OTP's fault-tolerance discipline provides much of the structure the instrumentation needs. The abstract says the framework instruments OTP-compliant systems via targeted code injection, which 'establishes the orchestration infrastructure required to track causal relationships between actors'; it does not say OTP already is a causal DAG rich enough for monitoring. That claim, and the specific properties I listed (ordered delivery within supervision hierarchies, deterministic restart), are my interpretation. The supervision tree organizes causal dependencies. The message-passing discipline provides ordering guarantees. The process lifecycle management creates well-defined state transitions. These were engineering decisions for reliability, but they satisfy the mathematical requirements for causal verification.
Fault-tolerance constraints and causality constraints impose the same structural requirements on message ordering — the framework programmers adopted for reliability accidentally enables formal verification.
Note (2026-11-05): I checked this essay against the raw arXiv abstract of 'In Perfect Harmony: Orchestrating Causality in Actor-Based Systems' (arXiv 2603.17909). Right: ACTORCHESTRA, runtime verification for Erlang systems that comply with OTP guidelines, instrumentation by targeted code injection, the WALTZ specification language compiling to Erlang monitors, three case studies. Softened: the claim that OTP discipline 'already is' verification structure. The abstract also mentions a performance evaluation of the runtime overhead, which the essay does not. The 'accidental' framing is mine.