Skip to main content

10. Implementation Roadmap

Below is a roadmap for CADL implementation and practical deployment, considering the research directions in Chapter 9. The periods are the originally planned ones; the status column records what the public reference implementation (cadl 0.3.36, as of November 2026) provides. For the up-to-date status, see the status table in the README of the cadl repository. The README lists features, not phases, so the two tables do not correspond row by row.

Phase
(planned period)
GoalContentStatus
Phase 1
(2026 Q2-Q3)
Language Core Design and Parser ImplementationEBNF finalization, parser implementation, type checker implementation. Initial evaluation via MAPF simulator integration.Done. Parser, type checker, and simulator IR / config generation (Python, Unity, Go) are available.
Phase 2
(2026 Q3-Q4)
Verification Engine (Basic)SMT-based consistency verification, protocol deadlock detection. Verification experiments on robot delivery scenarios.Done. Z3-based consistency checks and protocol deadlock detection are available. The model_check, simulation, and proof methods are not supported yet.
Phase 3
(2027 Q1-Q2)
Runtime and Code GenerationPython/TypeScript runtime generation, contract monitoring implementation. Demonstration on IoT data sharing scenarios.Partly available. Python runtime generation including contract monitor classes is available. TypeScript generation is planned.
Phase 4
(2027 Q2-Q3)
AI IntegrationNL→CADL conversion via LLM, regime recommendation engine. Evaluation on household rule design scenarios.Partly available. NL→CADL generation via an LLM with a parse / type-check / retry loop is available; with --verify, the generated definition also goes through the SMT and deadlock checks of cadl verify. The regime recommendation engine is planned.
Phase 5
(2027 Q3-Q4)
Institutional Transition and Regime MapsSafety verification of dynamic institutional switching, regime map construction support tool. Integrated experiments across domains.Partly available. Graph analysis of regime transitions (reachability, dead states, cycles) and a satisfiability check of safety invariants are available. From cadl 0.3.32: parameter values and the contracts in force per regime (regimes:, A.7.1), used by the IR, the simulator configurations, cadl verify, the generated Python code, and the designs of the stochastic model; the safety invariant of a transition in the IR. From cadl 0.3.33: the regime of each step of a run (A.7.1), so that cadl verify reports a conflict of two contracts that no regime has in force together as information; the bindings in cadl regime-map, in the norms monitor of the generated Python and cadl norms-eval, and in the generated Solidity and Rego, and a refusal by the targets that cannot apply them (D.1). From cadl 0.3.36: the norms monitors of the generated Rego and Solidity, the generated Unity C#, and the boundary policies of Appendix G follow the current regime too, and so do cadl agents-run and the MCP and A2A gateways (G.13). Safety verification of dynamic switching and the construction support tool are planned.
Phase 6
(2028 Q1-)
IEC 62853 Integration and Practical DeploymentAssurance case integration, smart contract generation. Real-world pilot projects.Partly available. An IEC 62853 mapping report and Solidity / OPA-Rego generation are available. Assurance case integration and pilot projects are planned.

The status column covers the tooling only; the evaluation experiments and demonstrations listed for each phase are outside its scope. The reference implementation also provides the SoS-DSL extension (Appendix E: lifecycle: / monitors:) with Unity C# generation, which the original phase plan did not list.

Six further extensions follow the research directions of Chapter 9 and are likewise outside the original phase plan. Each is specified in an appendix that states what the reference implementation provides:

ExtensionResearch challengesReference implementation (cadl 0.3.36)
Norms (Appendix F)RD-6.1, RD-6.2, RD-6.3, RD-6.5Static rules; verdicts and amendments computed from a recorded trace (cadl norms-eval, cadl norms-diff); an online monitor in the generated Python code (norms_monitor.py); quantifiers, aggregates and [*] references in predicates. From cadl 0.3.25: design-time checking of one contract instance with PRISM (cadl norms-check, F.12); monitors in the generated Rego and Solidity (D.5). From cadl 0.3.26: exact numbers and times; design-time checking of quantified predicates, comparisons and arithmetic over a given domain, several instances, and amendments. From cadl 0.3.29: design-time checking of four quantities ordered against each other (F.12), and in the Solidity monitor up to four temporal operators in one content and nested within and throughout (D.5). From cadl 0.3.30: a norm that could never be evaluated is an error (N-16, F.7). From cadl 0.3.31: design-time checking of five or more quantities compared with each other, and of four or more ordered quantities with a domain or linear arithmetic (within the limit on face points), by elimination (F.12), and in the Solidity monitor five temporal operators in one content and nested within and throughout of any depth (D.5). From cadl 0.3.32: an elimination that merges states equal up to a permutation of members, leaves out states that can only give combinations already found, and keeps representatives of the members for min and max, so that every pair of up to 8 members ordered by their indices and max of 8 members are checked, with the limit set by --max-states (F.12), and in the Solidity monitor six or more temporal operators in one content, until in a nesting, and operands that combine a nested operator with other parts, decided per observation (D.5). From cadl 0.3.36: the Rego and Solidity monitors of a contract that some regime does not have in force follow the current regime, on the clock of the contract (D.5). From cadl 0.3.36: the Rego and Solidity monitors generated with the other versions of a run follow the version in force, with the amendment of F.6 (D.5). Not provided: monitoring in the generated Unity C#, and in Rego and Solidity of what they refuse (quantifiers, aggregates, wildcard references, amendments of a trace, and versions to which running instances switch when the other versions are not given).
Agent governance (Appendix G)RD-8.1, RD-8.2, RD-8.3Static rules; the decision function for one message (cadl agents-decide); Rego and Cedar boundary policies; a reference runtime that replays a recorded trace with holds, delegation and audit records (cadl agents-run), also usable online; a tamper-evident audit log (cadl audit-verify); a gateway for the Model Context Protocol (cadl mcp-gateway). From cadl 0.3.25: a gateway for A2A 1.0.0 over JSON-RPC (cadl a2a-gateway). From cadl 0.3.26: streams of A2A, signed holds, and tests against the official MCP and A2A SDKs. From cadl 0.3.28: the HTTP+JSON binding, push notifications behind an allowlist, gRPC as the optional extra cadl-lang[grpc], and mutual TLS (G.13). From cadl 0.3.29: caps on the gRPC connections of each client address, through a front listener (G.13). From cadl 0.3.31: a maximum age of each gRPC connection, a fair wait for a place, and calls refused by gRPC itself counted as calls (G.13). From cadl 0.3.36: the decision function and the Rego and Cedar boundary policies read the current regime from the policy input (G.10), and the runtime and the gateways follow it, the gateways with changes of regime from their host (G.13). Not provided: other MCP transports than stdio.
Stochastic model (Appendix H)RD-1.3Static rules; export to the PRISM language (cadl model-export); a reference evaluator at fixed parameter values (cadl model-check); certified regime maps by parameter lifting (--certify). Not provided: derivation of the model from contracts.
Strategic model (Appendix I)RD-7.1, RD-7.2From cadl 0.3.23: static rules; checks that a named memoryless deterministic profile is an equilibrium against unilateral deviations, with deviation gains, and certified equilibrium maps (cadl game-check); export to PRISM-games; from 0.3.24 end-point certification for any strategic model and the concept every_reachable_state. From cadl 0.3.27: the performance-difference conditions PD+ and PD− of I.9 (one-step advantages), also used to decide maps, and the export checked with PRISM-games 3.2.4. From cadl 0.3.28: coupled bounds of the advantages for PD+ and PD− (I.9). From cadl 0.3.29: coupled bounds also for probabilities that are not multi-affine (I.9). From cadl 0.3.31: exact ranges of probabilities that are not multi-affine and bounds of the advantages through the Bellman equations of the profile, which leave fewer cells undecided (I.9). Not provided: equilibria under partial observation, concurrent moves.
Grounding of the institutional parameters (Appendix J)RD-6.1, RD-1.5From cadl 0.3.23: static rules; indices for α and β and a coverage measure for incentives (cadl norms-indices); the payoff term of a sanction in a strategic model; from 0.3.24 indices over all contracts of an SoS. Not provided: the formal meaning of α, β, and λ in terms of norms.
Amendment (Appendix K)RD-6.5From cadl 0.3.32: amendable parameters with their layer, the actor or role that decides, range, steps and locations; the version, its effective time and the transitional rule for running contract instances, related to on_amendment: of F.6; metric targets by period, time or version, measurement methods, and references to decision records; static rules K-1 to K-13, the IR addition, and the comparison of two versions under the declared amendability (cadl amend-diff). From cadl 0.3.34: versions, effective times, and transitional rules applied while a system runs (K.11) by cadl norms-eval and the norms monitor of the generated Python, with a time base or versions named by the trace; measurements judged against the target and schedule in force (cadl metrics-eval); version.py in the generated Python; refusals by cadl norms-check, the Rego and Solidity norms monitors, and Unity C# where they cannot apply versions. From cadl 0.3.35: versions together with regime bindings (K.11, "Versions and regimes"); previous: placed by the effective times; the key version for a file without versions; versions at their effective times in cadl agents-run and the gateways of Appendix G; target checks of the generated metrics.py with the versions of the run. From cadl 0.3.36: cadl norms-check --version with keep and switch with in_states: (K.11), and the Rego and Solidity norms monitors and Unity C# generated with the other versions of a run (cadl codegen --version), which follow the version in force, also with regime bindings. Not provided: an enforcement point (Appendix G) that keeps an instance on an older version or lets it wait for a state (keep, switch with in_states:); evaluating the formula of a metric.