runtime-verification-for-agents

Compile formal invariants into runtime monitors for agent coordination daemons.

2|Updated Feb 11, 2026
One-click install
npx skills add https://github.com/curiositech/port-daddy --skill runtime-verification-for-agents
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: runtime-verification-for-agents
Source: https://github.com/curiositech/port-daddy/tree/main/skills/runtime-verification-for-agents
Command: npx skills add https://github.com/curiositech/port-daddy --skill runtime-verification-for-agents

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Many agent coordination daemons implement complex concurrency and recovery logic where subtle invariant violations (data loss, ordering errors, claim conflicts) can corrupt state or trigger cascading failures; this Skill provides a practical pathway to convert formal invariants into lightweight runtime monitors that continuously audit live sessions and trigger safe remediation when properties fail.

Core Features & Use Cases

  • Invariant compilation: Patterns and guidance to compile safety (TLA+, Alloy) and bounded liveness properties into per-action or periodic checks.
  • Checking strategies: Decision trees for choosing synchronous, sampled, or hybrid monitoring based on criticality and latency budgets.
  • Remediation and safety: Safe remediation flows (alert, salvage, halt), double-check gates to avoid false positives, clock-skew handling with HLC/Lamport recommendations, and injection test guidance.
  • Operational guidance: Metrics to track monitor overhead and health (heartbeat canaries, false-positive rates, crash-loop policies) and examples for wiring monitors into daemon hot paths or background sweeps.
  • Use case examples: NoteMonotonicity as a synchronous monitor, CrashRecovery as a sampled/ bounded-liveness monitor, and Arbiter deployment patterns for autonomous monitoring agents.

Quick Start

Compile your TLA+ safety invariant into a (previous,current)->Violation monitor, wire cheap precondition checks into the hot path and schedule full sweeps in a background Arbiter agent to begin continuous auditing.

Frequently Asked Questions about runtime-verification-for-agents

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce TLA+ safety invariants at runtime for agent coordination daemons?

Runtime verification for agents compiles formal invariants into monitors that continuously audit live agent coordination daemon sessions and trigger remediation when properties fail. It handles safety and bounded-liveness properties through synchronous, sampled, or hybrid checking strategies.

What is the best way to monitor bounded-liveness properties in autonomous agent systems?

Runtime verification monitors bounded-liveness properties using sampled or hybrid checking strategies scheduled as background sweeps via an Arbiter agent. This enables continuous auditing of autonomous agent sessions without blocking critical hot-path execution or exceeding latency budgets.

Can I use runtime verification to handle clock skew in distributed agent coordination?

Yes, runtime verification handles clock-skew in distributed agent coordination by incorporating Hybrid Logical Clock (HLC) and Lamport timestamp recommendations into its compiled monitors. These mechanisms ensure accurate trace-checking and event ordering despite clock discrepancies across agent daemons.

When should I use synchronous monitoring versus sampled checking for agent invariants?

Use synchronous monitoring for critical agent invariants requiring immediate precondition checks in the hot path, and use sampled checking for less critical properties to stay within latency budgets. Decision trees based on criticality and latency constraints guide the choice between synchronous, sampled, or hybrid strategies.

How do I add safe remediation flows like alerting, salvage, and halt to runtime monitors?

Add safe remediation flows to runtime monitors by wiring double-check gates to prevent false positives, then triggering alert, salvage, or halt actions when invariant violations are confirmed. Injection test guidance and crash-loop policies ensure these remediation hooks operate safely in production environments.

Does runtime verification for agents support injection testing for invariant violations?

Yes, runtime verification for agents supports injection testing by providing specific guidance for injecting invariant violations into agent coordination daemons. This allows operators to validate that compiled monitors correctly detect failures and trigger appropriate remediation hooks under controlled conditions.