CHASE MCP Server
This server exposes CHASE assume-guarantee contract operations, checks, synthesis, repair, format conversion, and visualization as MCP tools.
Build and manipulate contracts: compose, conjoin/disjoin, merge, divide, separate, imply/coimply, invert, assume/ensure, saturate, simplify.
Check contracts and formulas: refinement, verification, compatibility, consistency, implementation/environment satisfaction, receptivity, redundant-term removal, implication, satisfiability, and unsat cores, with model-checker backends and counterexamples.
Perform GR(1) synthesis with slugs: realizability, controller/counter-strategy generation, unrealizable cores, well-separation, and vacuity checks.
Repair named constants to make checks pass or optimize values using z3.
Parse/write CHASE specs, SystemVerilog SVA, C contracts, SMV models, and RTL ports; check C functions with ESBMC/CBMC.
Visualize contracts, compositions, refinements, environments, and checks as web pages.
Exposes CHASE's assume-guarantee contract operations as tools: build contracts (compose, conjoin, disjoin, merge, quotient, separation, saturate, simplify) and check them (refines, consistent, compatible, realizable with controller/counter-strategy, contains_environment, contains_implementation), plus LTL implication/satisfiability checks and reading/writing specifications in CHASE's .ltl language, returning counterexamples an agent can use to fix a specification.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@CHASE MCP Server Check whether my Arbiter contract refines the spec, and explain the counterexample."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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
periodandlipschitz(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
synthit 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, andis_satisfiablereturn it withcore.
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_realizablereturns it withcore.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
constantsof 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 leastminimizeor greatestmaximize. It optimizes with z3 (pip install "chase-cps[z3]"), and every value it returns has passed the check itself. The status isholds(the present values pass: a verification),repaired,impossible(no values in the ranges), orunknown.
Specifications:
parse_spec and to_spec: read and write contracts in the logics language of CHASE (the
.ltlfiles oflogics_tool).parse_sva and to_sva: read the
assume propertyandassert propertystatements 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
LTLSPECandINVARSPECas 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;
environmentsdraws state machines as environments, andopendraws 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, andis_receptivetake 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
PATHor given with the environment variableCHASE_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-cpsOr 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 toolsassumeBRead-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_cARead-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.
coimplyBRead-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.
composeARead-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.
conjoinBRead-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.
disjoinBRead-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.
divideCRead-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.
ensureCRead-onlyIdempotent
Add a guarantee b to the contract: (b -> A, b & G). The result refines the contract.
Inputs: formula (required), contract (required), name.
impliesBRead-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.
implyCRead-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.
invertCRead-onlyIdempotent
Reciprocal (G, A): the contract seen from its environment. Inputs become outputs and outputs inputs.
Inputs: contract (required), name.
is_compatibleBRead-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_consistentARead-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_environmentBRead-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_implementationARead-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_realizableARead-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_receptiveARead-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_satisfiableARead-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_vacuousARead-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_separatedARead-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.
mergeARead-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_cARead-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_smvARead-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_specBRead-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_svaARead-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.
refinesARead-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_redundantARead-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.
repairBRead-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_portsBRead-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).
saturateCRead-onlyIdempotent
Saturation: the equivalent contract (A, A -> G). The other operations saturate their operands themselves.
Inputs: contract (required), name.
separateCRead-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.
simplifyBRead-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.
synthesizeARead-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_specBRead-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_svaARead-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_coreBRead-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_coreCRead-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.
verifyARead-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.
visualizeAIdempotent
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
Scored across 39 tools
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.
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.
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.
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
Related MCP Connectors
Machine-verifiable authorization checks for autonomous AI agents.
AI-native programming language and toolchain for accountable, verifiable agent-driven development.
Design, build and run teams of AI agents with checked handoffs between them.
MERCATOR Verify: evidence-backed verification and decision support for autonomous agents.
Related MCP Servers
- AlicenseAqualityCmaintenanceIntegrates 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.62PolyForm Noncommercial 1.0.0
- AlicenseAqualityDmaintenanceEnables AI agents to formally verify constant-time, masking, and patch completeness properties of Verilog hardware designs, providing concrete leakage signals and next-step guidance.12Apache 2.0
- AlicenseNot gradedqualityAmaintenanceEnables 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 npm8PolyForm Noncommercial 1.0.0
- AlicenseAqualityCmaintenanceEnables 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.314 npmApache 2.0