Skip to main content
Glama
CHASE MCP Server

CHASE MCP Server

by chase-cps

CHASE MCP server

This repository contains a Model Context Protocol (MCP) server and an agent skill for CHASE (Contract-based Heterogeneous Analysis and Systems Exploration).

The server exposes the contract operations of CHASE as tools that an AI agent can call: an agent can write assume-guarantee contracts, compose them, check refinement, and use the counterexamples returned by the model checker to fix the specification. The skill tells the agent how to use these tools.

Tools

The tools are in three layers.

1. Contract algebra. The operations that build contracts; each tool returns a new contract. They hold for any assume-guarantee contracts.

  • compose: parallel composition of two or more contracts; variables with the same name are connected. With discharge, the result keeps the terms of the contracts and drops the assumptions discharged by the other contracts (this uses the checks of layer 2).

  • conjoin and disjoin: conjunction and disjunction (greatest lower bound and least upper bound). With discharge, the conjunction keeps the terms (the same contract).

  • merge: merging of viewpoints of the same component. With discharge, the result keeps the terms of the viewpoints (the same contract).

  • divide: the quotient, i.e. the contract of a missing component. With discharge, the result keeps the terms (the same contract).

  • separate: separation, the adjoint of merging.

  • imply and coimply: implication and coimplication, the adjoints of conjunction and disjunction.

  • invert: the reciprocal (G, A), the contract seen from its environment.

  • assume and ensure: add an assumption or a guarantee.

  • saturate: the equivalent contract (A, A -> G).

  • simplify: rewrites the formulas, as the simplify command of logics_tool (negations moved to the atoms, temporal operators grouped).

2. Checks. Each tool returns a status and, when the check fails, a counterexample. The checks on contracts reduce to queries on formulas, which nuXmv decides. They take a context: formulas that every behavior satisfies, such as the axiom of an encoding of finite traces.

  • refines: whether a contract refines another one, and which part fails (assumptions or guarantees). With period and lipschitz (how fast each variable changes), the refinement is checked between the samples too, in continuous time; the intervals may then be written with times (G[0s,2s]).

  • verify: whether the assumptions and the guarantees can hold together (A & G satisfiable), which implies compatibility and consistency; is_compatible (some environment satisfies the assumptions) and is_consistent (some behavior satisfies the contract) check them one at a time.

  • is_implementation and is_environment: whether an implementation satisfies the contract, and whether an environment satisfies its assumptions, given as LTL formulas or as state machines (an SMV model, a state machine in JSON, or a controller from synthesize).

  • is_receptive: whether a state machine accepts every input that the assumptions allow, with the state and the input it refuses.

  • remove_redundant: removes the assumptions and guarantees implied by the other terms of the contract. By default it keeps A -> G, for the algebra and the checks; with synth it keeps realizability and the controllers, for synthesis (the terms redundant in the GR(1) game).

  • implies and is_satisfiable, on formulas: validity of an implication, and satisfiability of a formula (some behavior satisfies it; this is not the satisfaction of a contract by a component, which is is_implementation).

  • unsat_core: a minimal set of terms that cannot hold together; verify, is_compatible, is_consistent, and is_satisfiable return it with core.

3. GR(1) synthesis, with slugs. These tools are about synthesizing a component from a contract in the GR(1) fragment of LTL, not about contracts in general.

  • is_realizable: GR(1) realizability, with the counter-strategy of the environment when unrealizable; synthesize also builds the controller.

  • unrealizable_core: a minimal set of guarantees that is unrealizable; is_realizable returns it with core.

  • is_well_separated: whether the component can win by forcing the environment to violate its assumptions while it keeps its safety guarantees, with that strategy and the assumptions that cause it.

  • is_vacuous: whether the component can win without an output that a liveness guarantee asks for (vacuity in synthesis), with that strategy and the assumptions that allow it.

Repair:

  • repair: the values of named constants (the constants of a contract, used by name in its formulas) that make a check pass (refines, impl, env, verify, compat, consist), at the least change from their present values, or at the least minimize or greatest maximize. It optimizes with z3 (pip install "chase-cps[z3]"), and every value it returns has passed the check itself. The status is holds (the present values pass: a verification), repaired, impossible (no values in the ranges), or unknown.

Specifications:

  • parse_spec and to_spec: read and write contracts in the logics language of CHASE (the .ltl files of logics_tool).

  • parse_sva and to_sva: read the assume property and assert property statements of SystemVerilog as a contract (the statements not read are listed with the reason), and write a contract as a checker module for any tool that reads SVA.

  • parse_c: read the contracts written in a C file, one per function: the clauses of ESBMC, CBMC, or ACSL.

  • check_c: check each function of a C file against its own contract, one call at a time, with ESBMC or CBMC; a function with no clause is checked as code alone (overflow, division by zero).

  • parse_smv: read an SMV model with its LTLSPEC and INVARSPEC as a contract.

Diagrams:

  • visualize: draw contracts (JSON, or a specification) as a web page: a composition is a box with its parts inside, wired by their variables, a refinement is drawn inside the contract it refines, and the results of the checks are tags on the boxes; environments draws state machines as environments, and open draws contracts open. Returns the path of the page and the checks of each box.

  • rtl_ports: the ports of a Verilog or SystemVerilog module, read with Yosys; is_implementation, is_environment, and is_receptive take such a module (rtl) as the state machine.

A contract is given in JSON:

{"name": "Arbiter",
 "inputs": {"req": "bool", "n": [0, 3]},
 "outputs": {"grant": "bool"},
 "assumptions": ["G F !req"],
 "guarantees": ["G (req -> F grant)"]}

Variables are Boolean ("bool"), bounded integers ([low, high]), reals ("real"), or words ("word[8]", "signed word[8]": bit vectors whose arithmetic wraps around). Formulas use the standard LTL syntax: ! & | -> <-> G F X U R W, relations, arithmetic, numbers such as 20.5, and x' for the value of x in the next step; on words also x[7:0], x[3], ::, << >>, mod, and the bitwise & | xor !.

Related MCP server: hw-verify-mcp

Requirements

  • The CHASE Python package, chase-cps, installed with the server.

  • nuXmv for the checks (free for academic and non-commercial use), in the PATH or given with the environment variable CHASE_NUXMV; NuSMV where nuXmv cannot be used.

  • slugs for the realizability checks.

chase-cps install nuxmv --accept-license and chase-cps install slugs install them, and chase-cps doctor shows the tools found. The CHASE Docker image contains slugs and NuSMV; nuXmv, whose license does not allow redistribution, is added in a container with chase-cps install nuxmv --accept-license.

Installation

The server is a Python program that runs on the standard input and output. With uv there is nothing to install: uvx chase-mcp downloads and runs it. Otherwise:

$> pip install chase-mcp

and use chase-mcp in place of uvx chase-mcp below.

The development version is installed from the repositories:

$> pip install "chase-cps @ git+https://github.com/chase-cps/chase" "chase-mcp @ git+https://github.com/chase-cps/chase-mcp"

Claude Code

The server and the skill are packaged as a plugin:

/plugin marketplace add chase-cps/chase-mcp
/plugin install chase@chase-cps

Or only the server:

$> claude mcp add chase -- uvx chase-mcp

Codex

$> codex mcp add chase -- uvx chase-mcp

or, in ~/.codex/config.toml:

[mcp_servers.chase]
command = "uvx"
args = ["chase-mcp"]

Cursor, Claude Desktop, Gemini CLI, and other clients

Most MCP clients read the same JSON configuration. Add the server to the mcpServers object of the configuration file (.cursor/mcp.json or ~/.cursor/mcp.json for Cursor, claude_desktop_config.json for Claude Desktop, ~/.gemini/settings.json for Gemini CLI):

{"mcpServers": {"chase": {"command": "uvx", "args": ["chase-mcp"]}}}

VS Code uses servers in .vscode/mcp.json:

{"servers": {"chase": {"type": "stdio", "command": "uvx", "args": ["chase-mcp"]}}}

OpenCode uses mcp in opencode.json:

{"mcp": {"chase": {"type": "local", "command": ["uvx", "chase-mcp"]}}}

To set the model checker, add "env": {"CHASE_NUXMV": "/path/to/nuXmv"} to the server entry (environment in OpenCode, env = { ... } in Codex).

Skill

The skill is in skills/chase-contracts. It follows the Agent Skills format (a SKILL.md file with instructions), and it also works without the MCP server: the agent then uses the chase_cps Python package. The examples folder of the skill contains complete examples; each one is run by the tests, so the results they state are the ones CHASE returns.

  • Claude Code: installed with the plugin, or copy the folder to ~/.claude/skills/.

  • Codex: copy the folder to ~/.agents/skills/ (or .agents/skills/ in a project).

  • Other agents that support Agent Skills: copy the folder to their skills directory.

Testing

$> pip install ".[test]"

$> pytest

The tests need nuXmv (chase-cps install nuxmv --accept-license).

License

This project is released under the 3-Clause BSD License.

Available Tools

39 tools
assumeB
Read-onlyIdempotent

Add an assumption b to the contract: (b & A, b -> G). The result is an abstraction of the contract (it is refined by it).

Inputs: formula (required), contract (required), name.

check_cA
Read-onlyIdempotent

Check each function of a C file (text or a file path) against the contract written in its clauses (see parse_c), one call at a time, with ESBMC or CBMC (whichever is installed): valid, or invalid with the values of a failing call. A function with no clause is checked as code alone (safe: no overflow, division by zero, or bad pointer). functions: the ones to check (default: all).

Inputs: path, text, timeout, functions.

coimplyB
Read-onlyIdempotent

Coimplication, the adjoint of disjunction: the smallest contract C such that second refines the disjunction of C and first. (A2 | !A1, (G2 & !G1) | (A1 & !A2)), with first = (A1, G1).

Inputs: first (required), second (required), name.

composeA
Read-onlyIdempotent

Parallel composition of two or more contracts (the contract of the system made of the components). Variables with the same name are connected; no variable can be an output of two contracts.

By default the closed form ((A1 & A2) | !(G1 & G2), G1 & G2). With discharge, the result keeps the terms of the contracts: an assumption of a component implied by the component that drives its inputs is dropped, then the redundant terms; each test is one model-checking call. That result is an abstraction of the composition: a refinement proved on it holds for the composition, a failed one may not.

Inputs: contracts (required), name, backend, timeout, +1 more.

conjoinB
Read-onlyIdempotent

Conjunction (greatest lower bound) of two or more contracts: a contract that refines all of them, (A1 | A2, G1 & G2).

With discharge, the result keeps the terms (the same contract): each guarantee under the assumptions of its contract that the others do not imply; with the same assumptions, (A, G1 & G2). Each test is one model-checking call.

Inputs: contracts (required), name, backend, timeout, +1 more.

disjoinB
Read-onlyIdempotent

Disjunction (least upper bound) of two or more contracts: a contract refined by all of them, (A1 & A2, G1 | G2).

Inputs: contracts (required), name.

divideC
Read-onlyIdempotent

The contract of the missing component: the largest contract C such that part composed with C refines system. (A & G', (G & A') | !(A & G')).

With discharge, the result keeps the terms: it assumes the assumptions of system and the guarantees of part (under the assumptions of part that system does not give), and guarantees the guarantees of system and the assumptions of part. It is the same contract, then the redundant terms are dropped; each test is one model-checking call.

Inputs: part (required), system (required), name, backend, +2 more.

ensureC
Read-onlyIdempotent

Add a guarantee b to the contract: (b -> A, b & G). The result refines the contract.

Inputs: formula (required), contract (required), name.

impliesB
Read-onlyIdempotent

On formulas: validity. Is the LTL formula phi -> psi valid, i.e. true for every behavior? Returns valid, or invalid with a counterexample trace satisfying phi and violating psi. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: phi (required), psi (required), variables (required), backend, +2 more.

implyC
Read-onlyIdempotent

Implication, the adjoint of conjunction: the largest contract C such that the conjunction of C and premise refines conclusion. ((A2 & !A1) | (G1 & !G2), G2 | !G1), with premise = (A1, G1).

Inputs: premise (required), conclusion (required), name.

invertC
Read-onlyIdempotent

Reciprocal (G, A): the contract seen from its environment. Inputs become outputs and outputs inputs.

Inputs: contract (required), name.

is_compatibleB
Read-onlyIdempotent

Compatibility: is there an environment that satisfies the assumptions? sat with a witness trace, or unsat when the assumptions contradict each other; with core, the assumptions that contradict each other. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: contract (required), core, backend, context, +1 more.

is_consistentA
Read-onlyIdempotent

Consistency: is there a behavior allowed by the contract (A -> G satisfiable)? sat with a witness trace, or unsat when the guarantees contradict each other; with core, the guarantees that contradict each other. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: contract (required), core, backend, context, +1 more.

is_environmentB
Read-onlyIdempotent

Is the environment an environment of the contract (E |=_E C)? The environment is an LTL formula over the variables of the contract (environment): environment -> A must be valid; or a state machine (smv, machine, or rtl, as for is_implementation) every behavior of which must satisfy A. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: contract (required), rtl, smv, backend, +4 more.

is_implementationA
Read-onlyIdempotent

Is the implementation an implementation of the contract (M |=_M C)? The implementation is an LTL formula (implementation): implementation & A -> G must be valid; or a state machine, every behavior of which must satisfy A -> G. A machine that refuses inputs can implement a contract only because of that: check it with is_receptive. valid, or invalid with a trace and, in details.violated, the guarantees that this trace breaks (others may fail on other behaviors: check a term alone to know). context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out. The state machine is given as one of: smv, a program in SMV (the input language of nuXmv: MODULE main with VAR/IVAR, INIT, TRANS..., no specification) that declares the variables of the contract; machine, a state machine in JSON {"name", "inputs", "outputs", "states", "initial", "transitions": [{"from", "when", "outputs", "to"}]}: at each step, in its state, the machine takes a transition whose when (a formula over the variables) holds, sets the outputs of that step, and moves to to; or controller, the controller returned by synthesize, with the contract it was synthesized from in synthesized_from (default: the contract); or rtl, a Verilog or SystemVerilog module (see rtl_ports for its ports).

Inputs: contract (required), rtl, smv, backend, +6 more.

is_realizableA
Read-onlyIdempotent

GR(1) synthesis (slugs): realizability. Can a component choose its outputs so that the guarantees hold for every environment satisfying the assumptions? realizable, or unrealizable with the counter-strategy of the environment; with core, also the unrealizable core (see unrealizable_core). Needs slugs; the formulas must be in the GR(1) fragment.

Inputs: contract (required), core, timeout.

is_receptiveA
Read-onlyIdempotent

Does the state machine accept every input that the assumptions of the contract allow? A machine that refuses an input has no behavior with it, so is_implementation may hold only because it blocks the inputs. receptive, or not_receptive with the trace to the state after which it refuses an input (details: state and input). Uses the initial and safety assumptions; the inputs must be Boolean or integer ranges. The state machine is given as one of: smv, a program in SMV (the input language of nuXmv: MODULE main with VAR/IVAR, INIT, TRANS..., no specification) that declares the variables of the contract; machine, a state machine in JSON {"name", "inputs", "outputs", "states", "initial", "transitions": [{"from", "when", "outputs", "to"}]}: at each step, in its state, the machine takes a transition whose when (a formula over the variables) holds, sets the outputs of that step, and moves to to; or controller, the controller returned by synthesize, with the contract it was synthesized from in synthesized_from (default: the contract); or rtl, a Verilog or SystemVerilog module (see rtl_ports for its ports).

Inputs: contract (required), rtl, smv, backend, +4 more.

is_satisfiableA
Read-onlyIdempotent

On formulas: satisfiability. Does some behavior satisfy the LTL formula? sat with a witness trace, or unsat; with core, the conjuncts of the formula that cannot hold together. This is not the satisfaction of a contract by a component, which is is_implementation. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: formula (required), variables (required), core, backend, +2 more.

is_vacuousA
Read-onlyIdempotent

GR(1) synthesis (slugs): vacuity. Can the component win without an output that a liveness guarantee asks for (Bloem et al., FMSD 2021)? vacuous lists each such output with its mode, never (a winning strategy never sets it: the guarantee that names it is discharged by the assumptions) or eventually (a winning strategy stops setting it), and the strategy; with core, a minimal set of assumptions that lets it. not_vacuous; unrealizable when the contract itself is; unknown. The outputs checked are outputs, by default those that occur only positively in a liveness guarantee (G F ...).

Inputs: contract (required), core, outputs, timeout.

is_well_separatedA
Read-onlyIdempotent

GR(1) synthesis (slugs): well-separation. Can the component win by forcing the environment to violate its assumptions? separated when it cannot; not_separated with the controller that forces the violation, which means the assumptions are too weak or depend on the outputs; with core, a minimal set of assumptions that causes it. The component must keep its initial and safety guarantees while it forces the violation (with with_guarantees false, the guarantees are left out). Only violations forced from every initial state are detected.

Inputs: contract (required), core, timeout, with_guarantees.

mergeA
Read-onlyIdempotent

Merging of two or more viewpoints of the same component (e.g. function and timing): (A1 & A2, (G1 & G2) | !(A1 & A2)).

With discharge, the result keeps the terms of the contracts, (A1 & A2, G1 & G2), which is the same contract, then drops the redundant terms; each test is one model-checking call. Use it before is_realizable or synthesize, which need the terms.

Inputs: contracts (required), name, backend, timeout, +1 more.

parse_cA
Read-onlyIdempotent

Read the contracts written in a C file (text or a file path), one per function: the clauses of ESBMC (__ESBMC_requires, __ESBMC_ensures in the body), of CBMC (__CPROVER_requires, __CPROVER_ensures after the signature), or of ACSL (/*@ requires ...; ensures ...; */). The inputs are the parameters, the outputs FUNCTION_out (the return value) and the pointers written (*p is p). A function with no clause has a contract with no terms: check_c checks it for overflow, division by zero, and the like.

Inputs: path, text.

parse_smvA
Read-onlyIdempotent

Read an SMV model with its specifications (LTLSPEC, INVARSPEC; text or a file path) as a contract: the IVAR are its inputs, the VAR its outputs (a VAR with no ASSIGN is still an output: write an input as IVAR), the specifications its guarantees. is_implementation with smv set to the model (its specifications are left out) checks it. An enumerated type is read as the integers 0, 1, ... in the order written (in the traces too), a DEFINE in a specification as its definition. Not read: CTL, past operators, and a DEFINE written with case ... esac; the error says which.

Inputs: path, text.

parse_specB
Read-onlyIdempotent

Read the contracts of a specification in the logics language of CHASE (the .ltl files of logics_tool), given as text or as a file path.

Inputs: path, text.

parse_svaA
Read-onlyIdempotent

Read the assume property and assert property statements of SystemVerilog (a module, a bind file, or the statements alone; text or a file path) as a contract: assumptions and guarantees, with the widths of Verilog, $past, bounded sequences, and disable iff. The directions come from the module ports, or from inputs or outputs (the other signals are of the other kind). Returns the contract, the properties read (label, kind, formula, from_cycle: the cycle from which a property with $past is checked), skipped (statements not read, with the reason), covers, the clock, and undeclared (signals read as 1 bit), and names (hierarchical names: u1__state is u1.state; give them to to_sva). One clock per contract: clock ("posedge clk") chooses it.

Inputs: name, path, text, clock, +3 more.

refinesA
Read-onlyIdempotent

Does refined refine abstract (can it replace it)? Checks that the assumptions of abstract imply those of refined, and that the guarantees of refined imply those of abstract. status is valid, invalid (with failed and a counterexample trace), or unknown. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out. Continuous time: when a step is a sample taken every period seconds and each variable changes at most lipschitz per second (one number, or {variable: number}), the refinement is checked between the samples too: what refined assumes and abstract guarantees is made stricter, what is known is made weaker (chase_cps.sampled). Intervals may then be written with times: G[0s,2s], F[0ms,500ms]. The margins are a sufficient condition: valid shows it in continuous time; otherwise the status is unknown (not shown), never invalid; check without lipschitz to see whether it fails at the samples.

Inputs: refined (required), abstract (required), period, backend, +3 more.

remove_redundantA
Read-onlyIdempotent

Drop the assumptions implied by the other assumptions, and the guarantees implied by the assumptions and the other guarantees. Returns the contract and the terms removed (removed: each term with its part, and with core the terms that imply it); terms whose check did not finish are kept and listed in unknown. Choose synth by what the contract is for next. false (the default) keeps A -> G: before the algebra and the checks (compose, refines, verify, ...). true keeps realizability and the controllers: before synthesis (is_realizable, synthesize, is_well_separated, is_vacuous); a term is dropped only when it is implied in the GR(1) game, and each removed term has its kind (init, safety, justice). With synth the terms must be GR(1), and there is no context. The two differ only when the assumptions are wrong (unsatisfiable, or constraining the outputs). context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: contract (required), core, synth, backend, +2 more.

repairB
Read-onlyIdempotent

The values of named constants, within their ranges, that make a check pass, at the least change from their present values (the sum of |new - present|), or at the least minimize / the greatest maximize (a term over the constants). parameters: the constants that may change, {name: {low, high, integer}}; they are among the constants of the contracts. The check: refines (refined, abstract), impl or env (contract and implementation / environment as a formula, or smv, machine, rtl), verify, compat, consist (contract). status: holds (the present values pass), repaired (values, cost, optimal), impossible (no values in the ranges pass), or unknown with a reason. check is the result of the check with the values; the method (projection, counterexamples, witnesses, enumeration) and its rounds are given. time_limit (seconds) stops the whole repair: unknown, with the least cost proved so far (bound).

Inputs: check (required), parameters (required), rtl, smv, +13 more.

rtl_portsB
Read-onlyIdempotent

The ports of a Verilog or SystemVerilog module read as a state machine: the inputs and the outputs with their types ("bool", "word[n]"), as the variables of a contract checked against it, the reset (not an input when given), and start, the step from which the contracts are checked.

Inputs: rtl (required).

saturateC
Read-onlyIdempotent

Saturation: the equivalent contract (A, A -> G). The other operations saturate their operands themselves.

Inputs: contract (required), name.

separateC
Read-onlyIdempotent

Separation, the adjoint of merging: the smallest contract C such that system refines the merging of part and C. ((A & G') | !(G & A'), G & A').

Inputs: part (required), system (required), name.

simplifyB
Read-onlyIdempotent

Simplify the formulas of the contract, as the simplify command of logics_tool: negations are moved towards the atoms, and temporal operators are grouped (G f & G g becomes G (f & g)). The result is equivalent; no model checker is needed.

Inputs: contract (required), name.

synthesizeA
Read-onlyIdempotent

GR(1) synthesis (slugs): the controller (an explicit strategy) when the contract is realizable, or the counter-strategy of the environment. Needs slugs; the formulas must be in the GR(1) fragment.

Inputs: contract (required), timeout.

to_specB
Read-onlyIdempotent

Write contracts as a specification in the logics language of CHASE, which logics_tool and the other CHASE tools read.

Inputs: contracts (required), name. Returns: result

to_svaA
Read-onlyIdempotent

Write a contract as a SystemVerilog checker module: assumptions as assume property, guarantees as assert property, clocked by @(edge clock); a formula G p is checked at every cycle, any other once (initial). reset (e.g. "rst" or "!rst_n") disables the properties while it holds; bind, the name of a design module, adds a bind statement (ports connected by name; names, from parse_sva, connects the hierarchical names). Any tool that reads SVA can check the module. Real variables cannot be written.

Inputs: contract (required), bind, edge, clock, +3 more. Returns: result

unrealizable_coreB
Read-onlyIdempotent

GR(1) synthesis (slugs): a minimal set of guarantees that is unrealizable under all the assumptions: removing any of them makes the contract realizable. status is found with core (the contract with those guarantees), none when the contract is realizable, or unknown with the reason. Needs slugs.

Inputs: contract (required), timeout.

unsat_coreC
Read-onlyIdempotent

On formulas: a minimal set of terms that cannot hold together. Give a contract (its assumptions and guarantees, A & G, are searched: the core says whether the assumptions contradict each other, the guarantees do, or the guarantees cannot hold when the assumptions do), or formulas with their variables. status is found with core, none when they can hold together, or unknown with the reason. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: backend, context, timeout, contract, +2 more.

verifyA
Read-onlyIdempotent

Can the assumptions and the guarantees hold together (A & G satisfiable, the verify command of logics_tool)? status is that of feasible: sat with a witness trace, which also shows compatibility (A satisfiable) and consistency (A -> G satisfiable); unsat when the guarantees cannot hold when the assumptions do, and then compatible and consistent say whether the assumptions alone cannot hold. With core, an unsat result carries the terms that conflict (in feasible.core). context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

Inputs: contract (required), core, backend, context, +1 more.

visualizeA
Idempotent

Draw contracts as a web page: the contracts given as JSON, or the contracts of a specification in the logics language of CHASE (text, or the path of a file). Without draw and refines, the contracts are put together by their ports: an output and an input of the same name are wired; contracts with the same ports are versions of one part, and the first one is wired; a contract whose outputs several parts drive, and which gives them what they read from outside, has the parts drawn inside it. draw names the contracts to draw instead; NAME+NAME draws their composition, a box with the contracts inside, wired by the names of their variables. refines lists [refined, abstract] pairs: the refined one is drawn inside the abstract one, and checked against it. A decomposition is drawn and checked only when a pair names it: refines: [["Sensor+Controller", "Cruise"]]. An input of a part that no other part or input of the box drives is marked (its name in orange). environments lists [model file, contract] pairs: the state machine (SMV, JSON, or a controller of slugs) is drawn on the left of the contract, as an environment. check (the default) checks that the assumptions and the guarantees of each contract can hold together (A ∧ G, with the core when they cannot), and the refinements and the environments drawn; for a file (path), the results are kept next to it (FILE.results.json), and a check of contracts that have not changed is not run again. verify and realizable check each contract drawn, and mark the terms of a core when a check fails. open names the contracts drawn open (their terms, and the core of a check that fails). The page is written to output (default: a new temporary file) and opens in any browser. Returns its path, and for each box its checks.

Inputs: draw, open, path, text, +8 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 39 tools

    Disambiguation3/5

    The tools are all in a coherent formal-methods domain, but several have subtle boundaries: verify vs. is_consistent vs. is_compatible vs. is_satisfiable, and imply vs. implies are easy to confuse. The contract-algebra operations compose/conjoin/disjoin/merge/divide/separate are mathematically distinct, yet an agent must read carefully to choose correctly.

    Naming Consistency4/5

    Names are consistently snake_case and mostly follow recognizable patterns such as is_*, parse_*, to_*, and bare verb operations. The main deviations are mixed imperative and predicate styles, plus the near-collision of imply and implies, which slightly weakens predictability.

    Tool Count2/5

    Thirty-nine tools is far above the typical well-scoped range and creates a high cognitive load even for a rich formal-verification domain. Many tools are specialized and justified individually, but as a set it feels too large rather than neatly scoped.

    Completeness5/5

    The surface covers parsing from C, SMV, SVA, and CHASE specs; exporting to specs and SVA; contract algebra; satisfiability, refinement, implementation, and environment checks; synthesis and repair; and visualization. It is hard to identify an obvious lifecycle gap for the stated formal-methods purpose.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Integrates the Quint formal specification language into LLM workflows for accessible formal verification. It provides tools for type-checking, random simulation, exhaustive model checking, and syntax documentation.
      6
      2
      PolyForm Noncommercial 1.0.0
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to formally verify constant-time, masking, and patch completeness properties of Verilog hardware designs, providing concrete leakage signals and next-step guidance.
      12
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI coding agents to enforce spec-driven development and verify code before it is marked done, using six tools that catch invented APIs, scan for hallucinated content, check plugin conformance, sandbox-run tests, validate schemas, and record audit evidence.
      771 npm
      8
      PolyForm Noncommercial 1.0.0
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI coding agents and IDEs to prove SystemVerilog assertions with SymbiYosys (smtbmc+z3) and lint SVA syntax, returning honest verdicts such as PROVEN, FAILED, UNKNOWN, ERROR, or TIMEOUT.
      3
      14 npm
      Apache 2.0