Name: Zero-Trust Physics
Author: zerotrustphysics

Zero-Trust Physics MCP

A physics verifier for Super Intelligence. Every answer comes with a cryptographic proof.

not scanned Remote · Streamable HTTP No auth needed 16 tools v0.10.0

No reviews yet by zerotrustphysics The publisher’s own endpoint — this marketplace is not in the path

tools declared

—

trust score

remote

at its publisher

—

calls last 7d

What it does

A physics verifier for Super Intelligence. Every answer comes with a cryptographic proof.

Quickstart

# 1 — add it to Claude Code
claude mcp add --scope user --transport http zero-trust-physics-mcp https://mcp.zerotrustphysics.com/mcp

# 2 — ask your agent for something these tools do
#   list_cards, describe_card, verify_step and 13 more

Zero-Trust Physics costs nothing on mcprush: there is no plan to choose here, no cap to set and nothing mcprush can bill you for.

Publishernot claimed

zerotrustphysics1 server

1 category

All 1 server

Collected from a public index. Nobody has claimed this account, so nothing here was written by its author — claim it if it is yours.

Tool surface

What the model actually sees. Descriptions are diffed on every release — see version history.

Only tools that write or reach the network

Lists every domain and card this connection serves, each with one sentence, and count, how many there are. against_measurement is how the model did against its own measurements, in one of four words, "met", "missed", "met in part" or "not held to a measurement": it is accuracy and not fit, and a model that missed is still the served model of its thing.

No parameter schema on file.

Describes one domain and card pair: inputs, units, bounds, step limits, reject names and meanings, advisory flags, frame slots, and worked examples. With form "short" the answer is a page, enough to write a first request: what the model is of, how it did against measurement, each input with its unit and range, the names of its stops, and a worked request. Only the full form, the answer when form i

Parameter	Type	Required	Notes
domain	string	yes	The domain of the pair, as list_cards names it.
card	string	yes	The card of the pair, as list_cards names it.
form	string	no	Leave this key out, or "full", for the whole description; "short" for a page that is enough to write a first request.

Computes one anchored step of one card and returns the state it lands on, in decimals and exact hex, with its cryptographic proof (sha256_seal) and a receipt. parameters holds the card's phase fields, its load fields and dt_s, as describe_card gives them. A step whose request or whose landing state is outside the card is refused in one sentence, with the refusal's name in round brackets when it ha

Parameter	Type	Required	Notes
domain	string	yes	The domain of the pair, as list_cards names it.
card	string	yes	The card of the pair, as list_cards names it.
parameters	object	yes	The step's inputs: the card's phase fields, its load fields and dt_s, each a number (a vector field is an array of three numbers), and no other key. describe_card gives the fields of the pair, with ea
from	object	no	Optional: a sealed run to start from, as run_trajectory takes it.

Runs one card from a start state through segments of steps, each under its own load, and seals the run. The answer holds the outcome, the final state in decimals and exact hex, a frame for each recorded step, the run_seal and a receipt. record_every sets which steps are recorded, about 230 characters each; the final state comes back in full whatever is recorded. readout gives named quantities in d

Parameter	Type	Required	Notes
domain	string	yes	The domain of the pair, as list_cards names it.
card	string	yes	The card of the pair, as list_cards names it.
initial	object	yes	The phase fields of the card at the start of the run, each a number (a vector field is an array of three numbers), and no other key. describe_card gives them, with each unit and bound.
dt_s	number	yes	Step, in seconds. Held for the whole run.
record_every	integer	yes	A state is recorded at each multiple of record_every and at the last landed step. The size of the answer follows from the request: about 230 characters for each recorded state, plus the request as it
segments	array	yes	—
readout	object	no	Optional. Reads quantities without the frames: {"quantities": [names the card publishes], "first_past": {"quantity": <one of them>, "above" or "below": <level>}}. The answer then holds the named quant
from	object	no	Optional: start from a sealed run. request: that run_trajectory request as sent (it may hold its own from); run_seal: its seal; coupling: absent to continue the same card (describe_card says how), or

Checks the seal of a run. Short form, which needs only what is short: request is the run_trajectory request as it was sent, with its readout and its from when it had them (the answer's inputs holds neither), and run_seal is the seal its answer gave. The run is computed again, under a physics permit and the limits and refusals of run_trajectory, and the answer is holds (the seal given is the seal t

Parameter	Type	Required	Notes
request	object	no	With run_seal alone: the run_trajectory request as it was sent, with its readout and its from when it had them (the answer's inputs holds neither). It is run again, under a physics permit and the limi
inputs	object	no	The inputs of the run_trajectory answer, sent back as returned: the request that was run. It is hashed, not run. A card's fields, units and bounds are in describe_card.
frames	array	no	—
outcome	string	no	—
steps_landed	integer	no	—
reject	string/null	no	—
run_seal	string	no	The run_seal of the run_trajectory answer: with request, or as part of the whole answer.
final_state		no	—
final_residual_conservation_error_hex	string/null	no	—
max_residual_conservation_error_hex	string/null	no	—
state_digest	string/null	no	—
chain_seal	string	no	With request and run_seal: a chained answer's chain_seal.
links	array	no	Alone: a chain's answers in order.

Lists every field solver this connection serves, each with one sentence, and count, how many there are. against_measurement is how the model did against its own measurements, in one of four words, "met", "missed", "met in part" or "not held to a measurement": it is accuracy and not fit, and a model that missed is still the served model of its thing.

No parameter schema on file.

Describes one solver: inputs and bounds, outputs, invariants and tolerances, refusal names and meanings, the published reference, and a worked example. With form "short" the answer is a page, enough to write a first request: what the model is of, how it did against measurement, each input with its unit and range, the names of its stops, and a worked request. Only the full form, the answer when for

Parameter	Type	Required	Notes
solver	string	yes	The solver, as list_solvers names it.
part	string	no	Leave this key out to get the solver's whole description. Some long descriptions name, under 'more', parts kept back for asking: set part to one of the names listed there for that part alone. Only a n
form	string	no	Leave this key out, or "full", for the whole description; "short" for a page that is enough to write a first request.

Solves one field problem with one solver and seals the solution: the outcome, the result in decimals and exact hex, its invariants, the solution_seal and a receipt. parameters holds the solver's inputs as describe_solver gives them. example, in their place, is the name of a worked example describe_solver lists (example_solve, or a key beginning example_solve_), so a long worked input need not be t

Parameter	Type	Required	Notes
solver	string	yes	The solver, as list_solvers names it.
parameters	object	no	The inputs of the solver named in 'solver', each a number, a whole number, a word, a flag or an array as describe_solver gives it, and no other key. Every number of a solve request must be a finite, n
example	string	no	In place of parameters: the name of one of the solver's worked examples as describe_solver keys it (example_solve, or a key that begins example_solve_). The request is filled with that example's param

Checks the seal of a solution. Short form, which needs only what is short: request is the solve request as it was sent (the answer's inputs), and solution_seal is the seal its answer gave. The request is solved again, under a physics permit and the limits and refusals of solve, and the answer is holds, cause ("solution_seal" when the seal given is not the seal the request solves to), recomputed_so

Parameter	Type	Required	Notes
request	object	no	With solution_seal alone: the solve request as it was sent (the answer's inputs). It is solved again, under a physics permit and the limits of solve, and its seal is compared with solution_seal. Its f
inputs	object	no	The inputs of the solve answer, sent back as returned: the request that was solved. It is hashed, not solved.
engine_version	string	no	—
outcome	string	no	—
iterations	integer/null	no	—
reject	string/null	no	—
result	object/null	no	—
invariants	object/null	no	—
field_sha256	string/null	no	—
seal_parts	object	no	—
solution_seal	string	no	The solution_seal of the solve answer: with request, or as part of the whole answer.

Runs a declared plan of runs on one card, or of solves of one solver, and seals the rows under one root. A plan is a list of runs, a grid over a base run, or a seeded sample over a base run; a run is a run_trajectory request without domain and card. A plan of solves names solver in place of domain and card and is a list or a grid of solve requests. The answer is small by default: the head, which h

Parameter	Type	Required	Notes
domain	string	no	—
card	string	no	—
plan		yes	A path names one number: initial.<field>, dt_s, or segments[0].load.<field>, with the segment's number in square brackets and [0], [1] or [2] after a 3-vector field for one of its components. steps an
store	string	no	—
return	string	no	—
solver	string	no	A plan of solves: the solver, in place of domain and card. It takes no store and no return. A plan of solves is answered inline: a list, {"kind":"list","solves":[{"parameters":{...}}]}, or a grid, {"k
answer	string	no	Leave out, or "summary", for the head and one short summary row per row: the values it sets, outcome, steps landed, refusal name and seal; "states" adds each run's final state in decimals; "full" give

Checks the seal of a dataset. Short form: request is the run_dataset request as it was sent, and dataset_seal is the seal its answer gave. The plan is run again, under the permits and the limits of run_dataset, whatever its answer form, and the answer is holds, cause ("dataset_seal" when the seal given is not the seal the plan runs to), recomputed_dataset_seal when it holds (when it does not, no s

Parameter	Type	Required	Notes
request	object	no	With dataset_seal alone: the run_dataset request as it was sent (the head's request). The plan is run again, under the permits and the limits of run_dataset, and its seal is compared with dataset_seal
head	object	no	With rows and frames_hex: the head a run_dataset answer carries.
rows	array	no	With head and frames_hex: the rows a full run_dataset answer (answer "full") carries.
frames_hex	string/null	no	With head and rows: the frames a run_dataset answer carries, or null.
dataset_seal	string	no	With request: the dataset_seal of the run_dataset answer, compared with the seal the plan runs to. Alone: the seal of a dataset stored as files (return "file"), read from the connection's own folder o

Checks the receipt at the end of one response against the text before it. It takes no physics permit. The receipt covers every byte of the response before it, the decimal values included, and shows who produced the response or when in no way: it has no key. The receipt covers the request as it was written, number spellings included, while a seal covers its values: a request sent with 310 and the s

Parameter	Type	Required	Notes
response_text	string	yes	The exact text of a response as it was received, ending with the receipt.

Runs a run_trajectory request (without a readout) and compares one published quantity with the agent's measurements, each at a landed step. The answer is the error in numbers (rms, mean signed, greatest absolute, model minus measurement, each with its exact hex), the model value at every compared step in decimals (model_values) and exact (model_values_hex), and a hash of the measurements, under on

Parameter	Type	Required	Notes
run	object	no	One anchored run. Total steps must be <= 1000000. Recorded frames must be <= 10000. The shape of initial and of each segment's load depends on the pair: describe_card gives it.
solves	object	no	In place of run: a plan of solves as run_dataset takes it (solver and plan, a list or a grid, at most 64 solves). quantity is then one number the solver publishes in its result, and each measurement n
quantity	string	yes	The name of one number the card publishes in its state, a plain name that has a '_hex' sibling in the state. A flag is refused.
component	integer	no	0, 1 or 2: which of the three components of a 3-vector quantity is compared. Required when the quantity is a 3-vector, and refused when it is not. Any other value is refused.
measurements	array	yes	At most 10000. A measurement is compared with the state after landed step k. There is no interpolation and no time matching: a measurement is placed by its step, its time since the start divided by dt

Gives how to cite a card or a solver: the service itself first (Zero-Trust Physics, its maker and its address) and the paper (https://doi.org/10.5281/zenodo.23305697), then the people whose measurements the model stands on (authors, title, year, address, and what each asks of those who use its data), each as text and BibTeX. With domain and card, or solver, the answer is for that model; with neith

Parameter	Type	Required	Notes
domain	string	no	With card: a card, by the name find_model or list_cards gives; the two give the same names.
card	string	no	—
solver	string	no	In place of domain and card: a solver, by the name find_model or list_solvers gives.

Finds the served model for a real thing described in plain words, such as "a lithium cell discharging in the cold". It returns the best few cards and solvers, each with fit first (the words that matched, and model_of, the one real thing it is a model of) and then accuracy (compared_with, the data it was fitted to and the data held back and compared, and accuracy_against_measurement: whether it pas

Parameter	Type	Required	Notes
description	string	yes	The real thing, in plain words.
limit	integer	no	How many models to return; 3 when left out.

Finds where an outcome changes, and gives the run on each side. request is a run_trajectory or solve request written out, its domain and card or its solver by the name find_model or the lists give, with no from, readout or example; vary is the place of the one number to change, such as "segments[0].load.current_a", "initial.soc", "dt_s" or "parameters.load_n"; low and high are the two ends of the

Parameter	Type	Required	Notes
request	object	yes	A run_trajectory or solve request as that tool takes it.
vary	string	yes	The place of the one number to vary: "segments[0].load.current_a", "segments[*].load.current_a" for every segment, "initial.soc", "dt_s", "segments[0].steps", "parameters.load_n". A count is varied in
low	number	yes	One end of the span. low and high may come in either order; the smaller is taken as low.
high	number	yes	The other end.
level	object	no	Optional. {"quantity": <a published quantity>, "value": <number>}: the span is halved to where that quantity of the final state (of a solve: of result) crosses the value. {"quantity": <a flag>}: to wh

Free

$0 forever

Every tool — any call limit is its publisher’s, not ours
No card, and mcprush charges nothing for it
Runs at its publisher’s own address — this marketplace is not in the path
Nothing to cap, because mcprush bills nothing

Nothing here is billable: mcprush charges nothing to install Zero-Trust Physics or to call it, at any volume.

Where are you running it?

Tool surface

Release history

Zero-Trust Physics MCP

What it does

Quickstart

Where are you running it?

Tool surface

What counts against your monthly calls

Release history

See also