Boundry Verify
Boundry takes execution out of the model's hands.
The Boundry Substrate decides whether a submitted request may run, then executes it deterministically and signs a record of both. No model is loaded or called in governed operation. Boundry Verify checks that record, offline, on your own machine.
Why execution is separated
Taking execution out of the model's hands makes its actions checkable, and it is the first condition for governing them.
Language models, and the agents built on them, do not give the same answer twice. Instructions and guardrails shape what a model proposes. They do not make its output repeatable. A record of what such a system did cannot be checked by asking it again.
If that system's output is also the action, the action inherits the problem. It can be logged, but the log is the only witness, and the operator holds it.
It also means the only thing standing between a goal and an action is the author's own restraint. An agent that is told no can look for another way to the same goal, and when its output is the action, nothing outside it has to agree first.
A rule only binds something that cannot act around it. While a model's output is the action, a rule is advice that the model may or may not follow. Once execution sits outside the model, a rule has somewhere to be applied: the point where the Substrate decides whether work runs.
On the governed road (the path from a submitted intent to its record, inside the Substrate), whether work runs is decided by the Substrate, not by whatever authored the request, and a refusal is itself a signed record with its reason (E4). Governance means making the rules and enforcing them. Boundry is designed so that the rules are declared by the people who run it, never by the model that writes the request. Boundry does not decide what those rules say; it enforces them. What this kit shows today is the refusal side of that (E4). That holds for work submitted to the Substrate; a system that acts by some other route is outside it.
Boundry moves three things out of the author's hands and into a system that can be replayed and checked: the decision whether the work runs, the execution of it, and the record of both.
Boundry Verify is how anyone checks that record: that the plan executed is the one the request produced (E1), that each step from request to output is bound together (E6), that the same request executes to the same bytes (E2), and that nothing has changed since (E3).
The Boundry Substrate
It decides whether work runs, and then it executes it.
The Boundry Substrate performs governed execution. It is not a store of records made elsewhere: the runs in the evaluation kit are the Substrate's own, made in fresh processes against fresh roots, on macOS arm64 and Linux aarch64.
A person, a program or a model may write an intent. Whatever wrote it, it enters as a submitted intent, and everything after that happens on the governed road, where no model is loaded or called (E5).
On the governed road, governance and execution are one process. The Substrate first decides admissibility: an inadmissible request is refused, and the refusal is itself a signed record with its reason (E4). An admissible request becomes a sealed plan, whose identity is a deterministic function of its inputs: versions, intent hash, input hashes and pins (E1). The Substrate executes it, each link from intent to output hash-bound (E6). The decision and the act are made by the same system in the same run, and both leave the same kind of record: a kernel export, the Substrate's signed record of one run, carrying the record's own signed payload bytes, its form hashes, the bodies it names, and the intent as submitted.
Records are tenant-scoped; a tenant scope says which records a read is for. A read with no declared tenant scope is refused, never widened, and the Substrate's own absent-scope refusal ships inside the verifier.
One key signs every record in the kit, and the kit ships only its verifying half. A valid signature shows that key signed the record and that it has not changed since. It does not show that anyone independent saw it happen.
On this page, governed execution means these six things together, each a README claim about the records in the evaluation kit, each held by a named check.
Why deterministic execution matters
Determinism turns a record into a claim anyone can check.
The kit measures determinism: the same governed request, run on two platforms by different people, produced byte-identical outputs, plan body, result and payload signatures; only wall-clock stamps, and hashes taken over them, differ (E2). The measurement matters less than what it makes possible.
A plan's identity can mean something
Because execution is deterministic, an identity that is a function of the plan's inputs (E1) names one outcome rather than a family of them. Two runs that share those inputs are expected to agree, and where they differ, the answer names each differing field and marks the expected ones with the reason. A difference is a finding, not noise.
README · E1, E2
Comparison can replace re-execution
If two runs of the same request must agree byte for byte, checking a run means comparing hashes: against another run, or against the run's own record. That is what compare_runs does, and how a changed output byte, a forged hash or a lost output is caught. The Substrate does not have to be present, and nothing is re-run.
README · E2, E3, compare_runs
The author drops out of the chain
With no model loaded or called in governed operation (E5), and execution deterministic (E2), what a run produced is fixed by its inputs (E1). Whatever authored the intent, the record does not depend on it. The record carries the intent's hash, not the author's account of the intent.
README · E5, E1, E6
Why independent verification follows
A verifier needs only what the record carries, so it can be small, offline and separate.
Put the properties together and the verifier's shape is forced rather than chosen. A plan's identity recomputes from six inputs, so anyone who has them can recompute it (E1). Each link from intent to output is hash-bound, so it recomputes offline (E6). The payload is signed and one verifying key ships, so a signature checks without the signer present. Runs are deterministic, so a run is compared by hash rather than re-executed (E2, E3). And no model is loaded or called on the road (E5), so nothing in the run has to be trusted rather than recomputed.
So a verifier needs the record, the intent as submitted, and a verifying key, which is exactly what each run in the kit ships. It needs no network, no database, no emitter, none of the Substrate's dependencies, and nothing that signs. Boundry Verify is built to that shape: seven read-only tools, standard library only, on your own machine.
So each question a reviewer asks has a record behind it, not a log:
The architecture
Two boundaries, and what each one keeps out.
The first boundary is where governed operation begins; inside it, no model is loaded or called (E5). The second keeps the verifier independent of the thing it verifies: a separate package, on your machine, with nothing that signs.
Core principles
Five things the records let you check.
Authorship is separate from execution
The intent is submitted; governed operation does the rest. The record carries the intent's hash, and every link recomputes offline.
README · E6
No model in governed operation
No model is loaded or called in governed operation. The kit ships this as a result (E5).
README · E5
Governance is recorded
A plan's identity is a function of its inputs; the body is identified by the seal's content hash; the output's hash is in the record; the payload is signed.
README · E1, E3, the evaluation kit
Refusal is a recorded outcome
The Substrate refuses an inadmissible request, and the refusal is itself a signed record with its reason. The kit's three workloads include one refused request.
README · E4, the evaluation kit
Verification is independent
A separate, read-only package on your machine. The kit ships verifying keys and nothing that signs; an evaluator verifies and does not re-sign.
README · What it is, the evaluation kit
Where Boundry Verify fits
The verifier for this architecture, not the architecture.
Nothing above is done by Boundry Verify. The Substrate refuses, seals, runs and records. Boundry Verify reads the records the Substrate leaves and checks them on your machine, with the Substrate nowhere in the picture: no database, no emitter, no network.
Trusting a record should not require trusting the system that wrote it. The architecture above is what makes that possible; the verifier is built to be able to do no more than the architecture requires. It has seven tools, all read-only, and there is no write tool and no disabled one.
| Tool | What it answers |
|---|---|
verify_record | a record in, the verifier's verdict out |
get_envelope | one envelope, tenant-scoped |
query_envelopes | envelopes in scope |
chain_status | head, era, manifest seq, sweep figures, instrument named |
explain_record | a record's provenance, rendered from artefacts; for a kernel export, its lineage link by link |
check_plan_identity | a sealed plan's id recomputed from its six inputs, and its seal checked |
compare_runs | two runs, each against its own record, then field by field: EQUIVALENT, DIVERGENT or UNREACHABLE |
The table is the README's. Every tool takes corpus_dir, by label or path, and every tool declares itself read-only in its own declaration.
What can be established
Six things the evaluation kit lets you check, and what it does not show.
Each line below is the README's claim, shortened. The README's exact wording, and the check that holds each one, are at The evaluation kit. The scope of every one is: records in the evaluation kit.
E1 · A plan's identity is a deterministic function of its inputs.
Versions, intent hash, input hashes and pins. It does not identify the plan body; the body is identified by the seal's content hash, and the answer says so.
E2 · The same governed request gave byte-identical results on two platforms.
macOS arm64 and Linux aarch64, in fresh processes, by different people on different machines: outputs, plan body, result and payload signatures identical. Only wall-clock stamps, and hashes taken over them, differ.
E3 · Tampering after the fact is detected.
A changed output byte, a forged hash, or a lost output. This is hash comparison, not re-execution, and it is not offered as E2.
E4 · A refusal is itself a signed record with its reason.
The Substrate refuses an inadmissible request, and the refusal is recorded like any other run.
E5 · No model is loaded or called in governed operation.
The kit ships the result of that check and the sha256 of the instruments that produced it, not their source. This item is a result, not a check you can re-run here.
E6 · Each link from intent to output is hash-bound and recomputes offline.
Each run ships with its submitted intent beside it, because the record carries the intent's hash and not the intent.
Try it
The evaluation kit, in three prompts.
The package ships evidence from real governed runs of the Boundry Substrate: one calculation, the smallest real transformation chain, and one refused request, each run on both platforms. Three tampered copies of one export sit beside them, and one verifying key. The inputs are synthetic.
Have Python 3.12 or newer.
The package declares the floor and enforces it: below 3.12 it refuses before doing any work, naming the floor and the version it found. The Python that ships with macOS is older; install a current one from python.org or your package manager.
Download the .mcpb from Releases and open it with Claude Desktop.
The .mcpb is a zip file. The code, the documents and the check command are inside it. On the install screen, leave “Folders the connector may read” empty to use the packaged kit; a folder entered there replaces it.
Ask about the packaged folders by name.
Every tool takes corpus_dir, and it takes a name. With nothing configured, kit is the evaluation kit and demo the demonstration records, so the first call works before anything is set up. A folder you declare as label=path answers to its label; a bare path answers to its path. An undeclared label is refused, and no path is shown.
“Use Boundry Verify to compare runs calculation-m2 and calculation-linux-aarch64 in the kit, global scope.”
You should see EQUIVALENT. The answer names each field that differs and marks every one as expected, with the reason: the wall-clock stamps, the hashes taken over them, each run's environment (its interpreter, operating system, machine and packages), the platform that ran it, and the run's own label. Nothing else differs.
“Compare calculation-m2 with calculation-m2--forged-hash in the kit, global scope.”
You should see DIVERGENT: the forged hash is caught for what was done to it, by hash comparison, not re-execution.
“Explain record transformation-m2 in the kit, global scope.”
You should see the export's lineage link by link, from submitted intent to output, each link recomputed offline.
The repository is also a plugin for Cowork and Claude Code. It runs the same server and reads only the packaged folders, kit and demo.
Then run the package's own checks from its unpacked folder:
python3 -I -B -m unittest discover -s server/boundry_connector -t server
Standard library only: no test framework to fetch, no network, no configuration. Expect 0 failures and 0 skipped. Running them does not alter the package; its tree digest is the same before and after.
Questions a reviewer asks
FAQ
What is Boundry?
Boundry is the architecture. Its centre is the Boundry Substrate, which performs governed execution and leaves a signed kernel export for each run. On the governed road an inadmissible request is refused and the refusal is recorded (E4); an admissible one becomes a sealed plan whose identity is a function of its inputs (E1); execution is deterministic (E2); and no model is loaded or called (E5).
Boundry Verify is the verifier for that architecture, not the architecture: a separate package that reads the records and checks them. It reaches none of the Substrate's declared dependencies, and its own import chain is standard library only. The Substrate itself does not ship here.
Does this make AI safe?
It changes where the danger sits. Much of the concern about AI is about what it might do. In Boundry, a model does not do anything. It proposes. Whether the work runs is decided by the Substrate, which also carries it out, with no model loaded or called (E5). When a request is refused, the refusal is a signed record with its reason (E4). Anything else the model tries is a new request, and it is checked the same way.
Put simply: the AI can be the brain, and Boundry is the hands. The hands are designed to move only under rules declared by the people who run Boundry, never by the model. The question stops being “what will the model do?” and becomes “what do our rules say?”, and every answer is on the record.
What this does not cover: a rule can still be wrong; work that reaches the world by some other route is outside the Substrate; and the kit shows the refusal side today (E4), not yet a declared rule set being enforced.
Is the model ever in control?
In governed operation, no model is loaded or called (E5). The kit ships the result of that check and the sha256 of the instruments that produced it, not their source, so it is a result you read rather than a check you re-run here.
Outside governed operation, in your Claude Desktop conversation, a model reads whatever the verifier's tools return. That is the point of the connector, and why the privacy policy says your conversation is not private.
What happens when something is refused?
The Substrate refuses an inadmissible request, and the refusal is itself a signed record with its reason (E4). The kit's three workloads include one refused request, run on both platforms.
The verifier refuses too, for named reasons: a read with no declared tenant scope, a folder you have not declared, a link whose final target is outside a declared root. A refusal never renders a path.
What can the verifier see or change?
It reads sealed records from folders you name, and nothing else; with nothing configured, that is the two packaged synthetic folders. It cannot sign, writes nothing, subscribes to nothing and attaches to no database. Where it compares, it compares hashes, not re-executions.
Does it need the internet?
No. It opens no socket and contacts no endpoint, and nothing in its checks depends on the network. It depends on nothing outside Python's standard library: importing the package pulls in zero third-party distributions, measured rather than recalled.
What does “offline verification” actually check?
For a record in the kit: that a sealed plan's id recomputes from its six inputs and its seal checks (E1); that each link from intent to output recomputes (E6); that two runs are equivalent or divergent field by field, by hash (E2, E3); and that a refusal is a signed record with its reason (E4). It checks against the verifying key in the kit, and it does not re-execute.
What doesn't it show?
The README's ceiling: one key signs everything and you hold it; the determinism shown is for the governed road, on the workloads in the kit, across the platforms named. A valid signature shows that key signed the record and that it has not changed since; it does not show that anyone independent saw it happen.
So: synthetic inputs; one verifying key; E2 on three workloads and two platforms; E3 by hash comparison, not re-execution; E5 a result, not a re-runnable check; and a conversation that is not private. The full list is beside What can be established.
Where is the technical evidence?
In the README, which names a check for each claim on a Held by line, and inside the .mcpb, which carries the code and the checks. If your measurement disagrees with this page, the measurement wins; verify@boundry.tech is where to say so.
Technical evidence
The README is the evidence document. This page is the map to it.
Every claim this page makes about the system is one the README makes, and the README names the check that holds it. Some of those checks, as the README names them:
it_opens_no_socket_and_contacts_no_endpoint
it_cannot_sign
it_neither_writes_nor_subscribes
it_attaches_to_no_database
there_is_no_write_tool_and_no_disabled_one
every_tool_declares_a_title_and_the_four_hints
a_read_with_no_declared_scope_REFUSES_and_is_not_widened
a_folder_you_have_not_declared_is_refused_for_THAT
a_refusal_never_echoes_the_path_you_named
E1_each_sealed_plan_recomputes_its_id_and_its_seal
E2_the_same_request_on_each_platform_is_EQUIVALENT
E3_each_tampered_copy_is_caught_for_what_was_done_to_it
E4_the_refusal_is_a_signed_record_with_its_reason
E5_the_conduct_line_result_ships_with_its_instruments_digests
E6_each_run_walks_link_by_link
the_package_carries_verifying_keys_and_no_secret
no_document_makes_a_claim_the_code_does_not_hold
For the design, threat model and evaluation, see the preprint and research notes at github.com/Boundryos/research.
Free to use; not open source. You may install and use the package unmodified, including to evaluate it and to verify records with it. The licence ships beside the README as LICENSE.txt.