MITR Proven-Action Gateway · 20 Active Enforce Contracts · Zero-Trust Credential Custody

MITR: protection against inadmissible actions of autonomous agents

MITR is not a language-model filter; it is a deterministic pre-execution gateway holding target credentials outside the agent runtime. Each proposed database write, file access, or payment request is translated into quantifier-free linear integer arithmetic (QF_UFLIA) and blocked in 1.08 milliseconds unless proven admissible under signed organizational policy.

20 / 20 Production security contracts running in enforce mode
1.08 ms Median per-contract solver decision (p95: 1.96 ms)
5,079 / 5,079 Epoch-33 decisions replayed identically (5,373 live records as of 15.11.2026)
Apache-2.0 Open client packages and standalone hash-chain verifier

Interactive MITR deterministic gate simulator

Client-side predicate evaluation + live WebCrypto SHA-256 receipt chain
Generation 2 · Probabilistic language-model guardrail
BYPASSED (~420 ms GPU)


    
Generation 3 · MITR Z3 SMT contract (QF_UFLIA)
UNSAT · BLOCKED BEFORE EXECUTION

    
SHA-256 RECEIPT VERIFIED · EPOCH 33

Three generations of enterprise control over software agents

Model Context Protocol (MCP) OWASP Top 10 for Agentic Applications EU Artificial Intelligence Act (Articles 9, 12, 14, 15) ISO/IEC 42001 NIST AI Risk Management Framework SOC 2 Audit Evidence
Engineering dimension Generation 1 · Static API gateways & role-based access control (RBAC) Generation 2 · Probabilistic LLM guardrails (NeMo, Llama Guard, Lakera) Generation 3 · Pre-execution SMT action gate (ISSLAB MITR)
Object inspected Network endpoint and static role token under RBAC Natural-language prompt and completion surface phrasing Structured tool call, typed parameters, target state, and credential custody
Decision mechanism Static route allowlist without payload semantics Secondary neural classifier estimating probability of harm Deterministic Satisfiability Modulo Theories (SMT) proof in the Microsoft Research theorem prover (Z3) over QF_UFLIA
Latency & compute < 1 ms CPU (blind to business invariants) 250–800 ms on graphics processing unit (GPU) per call 1.08 ms warm median on standard 4-core CPU (zero GPU tokens)
Indirect prompt injection Passes any destructive call permitted to the service account Susceptible to paraphrase, encoding, and multi-turn framing Invariant to prompt wording; blocks any call lacking a formal proof
Refusal feedback & audit Hypertext Transfer Protocol (HTTP) 403 status code; mutable application log Opaque confidence score; no mathematical witness Exact violated clause (Unsat Core) + OpenTimestamps SHA-256 receipt chain

OWASP Top 10 for Agentic Applications (ASI01–ASI10) coverage

Agentic risk class Failure mode without deterministic gate Information Security 3.0 control (MITR Z3 + INDRA Field Edition)
Goal Hijack & Context Poisoning (ASI01, ASI06) Indirect instructions inside documents or retrieval corpora redirect agent actions Typed tool-call Z3 invariants enforce fixed scopes independent of prompt prose; INDRA probes INDR-09–INDR-14
Tool Misuse & Unexpected Execution (ASI02, ASI05) Excessive parameters, destructive filesystem writes, or arbitrary shell execution QF_UFLIA parameter bounds, path denylists, and container allowlists checked in 1.08 ms prior to execution
Identity Abuse & Supply Chain (ASI03, ASI04) Raw credentials inside prompt context or compromised public Python packages Zero-trust credential custody held inside MITR gate; offline SHA-256 pinned wheels (--no-index)
Cascading Errors & Rogue Autonomy (ASI07–ASI10) Unbounded retries, unverified inter-agent trust, and mutable logs lacking accountability Unsat Core counterexamples, 3-retry circuit cap, and OpenTimestamps SHA-256 audit chain (5,373 records)
Executive liability and governance rationale

For the head of the organization: autonomous agent actions as a matter of responsibility

This section is addressed to the chief executive, the business owner and members of the board: those who decide to deploy autonomous agents and answer for the consequences.

The agent acts but is not liable

An autonomous agent is not a subject of law: the parties to legal relations remain individuals, organizations and the state. An agent’s action is legally an action of the organization that used it, and the organization bears the consequences of a mistake: a leak, a wrong payment, deleted data. How this works under Russian law is described on the page who is liable for the mistakes of artificial intelligence.

The usual protection does not see the threat

Antivirus, firewalls, data leak prevention and monitoring systems are built to find an outsider: malware, an intruder, someone violating access rights. An agent works inside the perimeter with the rights it was given, and its commands are correct in form. The danger is not in who acts but in what action is chosen.

The regulator holds the organization to account

The requirements for information protection, for the security of critical information infrastructure and for processing personal data are addressed directly to the operating organization. In an inspection or a dispute, it will have to answer three questions: who allowed the action, under which rule, and what proves it.

MITR answers all three with a receipt that is produced automatically for every action of the agent.

How it works

The easiest way to explain MITR is a fuse box. A circuit breaker opens the circuit on overload before a fire starts, and it does so without an electrician, which is why nobody in the house thinks about the wiring. MITR plays the same role for autonomous agents: it sits in the break between the agent and the information systems and checks each action before it runs.

  1. The autonomous agent forms an action: sending an email, a payment, changing or deleting data, exporting information.
  2. MITR checks, before execution, whether the action complies with the organization’s rules.
  3. Admissibility proven. The action is executed, and a receipt is written to the log: what action was taken, under which rule, and when.
  4. Admissibility not proven. In enforce mode the action is not executed; in advisory mode the agent receives a warning; in both cases, a list of the violated conditions, so that the plan can be changed.
  5. An internal auditor or an outside verifier re-checks the log of receipts without trusting MITR’s developer.

Checking one action takes a few milliseconds. The agent does not have to wait for approvals, and the security team gets not assurances but a log it can verify.

What the organization gets

  • Preventing damage instead of investigating it. In enforce mode, an action whose admissibility has not been proven is not executed. Protection starts with irreversible actions: deleting data, payments and sending information outside the perimeter.
  • An evidence base for inspections and disputes. Instead of an explanatory note, the organization presents a sample of receipts: what actions the agent took, under which rules they were allowed, what was stopped and why.
  • Freedom to choose suppliers of artificial intelligence. MITR does not care which model proposed an action, domestic or foreign, open or closed: it checks the action itself. Agents can be replaced without revising the protection.
  • The organization’s own rules. An admission rule is stored as a data file, and the security team adds or changes rules without rewriting program code.

How MITR covers the organization’s risks

Each risk that arrives with agents has a matching mechanism of MITR and a verifiable result.

RiskMITR mechanismResult
An agent performs an irreversible action: deletes data, makes a payment, sends information outside the perimeter.The action is checked before it runs; classes of irreversible actions are moved to enforce mode, and an unproven action is not executed.Damage is prevented before the event rather than investigated after it.
An attacker plants an instruction in a document, an email or a web page that the agent reads (indirect injection).The check applies to the technical action itself: an inadmissible call stays inadmissible regardless of who suggested it.An attack through data does not turn into an action.
The organization is liable for the agent’s actions but has no evidence that they were lawful.Every decision is recorded as a receipt: the action, the rule, the facts, the verdict and the time. Receipts are linked into a chain whose head is fixed daily by an external time witness.The organization shows, with a sample from the log, that the agent acted under its rules.
The regulator requires control over the use of artificial intelligence and protection of information, including at critical information infrastructure.Admission rules limit the transfer of protected information and dangerous operations, and the log records every decision.Compliance is confirmed by verifiable log records.
The supplier’s model is closed or hosted abroad, and its behaviour changes with every update.MITR operates independently of the language model because rules apply directly to the parameters of the action.Changing the supplier of artificial intelligence does not require revising the protection.
Approvals slow work down: the security team wants to approve every action, and the business wants to keep its speed.A check takes a few milliseconds and replaces manual approval with a receipt.The agent works without waiting, and the security team gets a report instead of a queue of requests.
Protocol flow over Model Context Protocol (MCP), current capabilities, and 4-step deployment

How IS 3.0 differs from the usual protection

Security of earlier generations (IS 2.0) assumes that the organization’s own employees work inside the perimeter and that threats come from outside. An agent removes that assumption: it is inside, it is not a person and holds no position, and its mistake, or an attacker’s instruction hidden in a document it has read, looks like a legitimate command.

Usual protection (IS 2.0)MITR (IS 3.0)
What is protectedThe network, workstations and employee accounts.The agent’s action at the moment before execution.
What it looks forAn outsider: malware, an intruder, someone violating access rights.An inadmissible action, regardless of who performs it.
How it decidesBy indicators, signatures and access rights.By proof: an SMT solver checks the action against the organization’s rules.
What the organization is left withEvents and alerts that need to be analysed.A receipt for every decision, which an outside specialist re-verifies.

MITR does not replace antivirus, firewalls and monitoring: they are still needed against external threats. MITR covers the layer that these tools cannot see by their design: the actions of the organization’s own agents with the rights they were given. The more of the work agents do, the larger the share of operations that passes through this layer.

More on the three generations of protection on the page IS 3.0: security of autonomous agent actions.

Connecting agents over the Model Context Protocol, with a proof and a receipt

Autonomous agents connect to tools and information systems through the open Model Context Protocol (MCP); see what MCP is. The protocol is like a standard socket: any agent can be plugged into any system, a database, email, an accounting program, a code repository. The protocol defines how to connect, but it does not answer whether a specific action is admissible.

Connection through MITR = the MCP protocol + a proof of admissibility before execution + a receipt after it

  • MCP: agent to system. The agent’s call goes straight into the system: there is neither a permission nor a record that can be verified.
  • MCP through MITR: agent through MITR to system. The call is executed only after its admissibility has been proven, and every decision leaves a receipt.

For the agent, connecting through MITR is no different from the usual way: MITR answers over the MCP protocol like an ordinary server, and the open package installs as a wrapper around an MCP server that is already connected. For the organization, every call gets a permission and a trace.

What the current version can do

The working version of MITR has run continuously since 24 April 2026: the actions of the institute’s coding agents and service bots pass through MITR. Below are the capabilities that the current version already provides.

  • Check before execution. An agent’s actions, such as deleting data, writing a file, sending a message, publishing, stopping a service or deploying code, are checked against the rules before they are executed.
  • Introducing protection step by step. A mode is set for each class of actions: shadow (observation), advisory (warning) or enforce. Protection is introduced step by step and does not stop the work.
  • A refusal with an explanation. When it refuses, MITR gives the agent the list of violated conditions of the rule and options for a fix, so the agent changes its plan instead of repeating an inadmissible attempt.
  • Rules as data. An admission rule is stored as a data file. A new rule is added without changing MITR’s program code.
  • Extending the vocabulary. The vocabulary of recognized actions grows from the log of requests. A new rule of the vocabulary is adopted only after it has been checked on the body of earlier actions, through the same system and with a receipt.
  • An evidential log. Decisions are linked into a chain of receipts. The head of the chain is fixed daily by an external time witness, and the decisions can be re-verified with an independent solver, without the developer.
  • Independence from the model. MITR does not care which model proposed an action: it checks agents from domestic and foreign, open and closed suppliers in the same way.
  • Connection without rebuilding the agent. MITR connects over the MCP protocol, through a Hypertext Transfer Protocol (HTTP) call from the organization’s own code, as a wrapper around an MCP server, or with one import into a Python agent. The open package keeps its log under the Russian national standard GOST R 34.11-2012 (GOST stands for the state standard).

The deployment path

Deployment goes through six steps, and the agents’ work does not stop at any of them. The delivery set, the site requirements and the timing by stage are described on the page “A pilot of MITR at a customer”.

  1. Trial installation. A specialist installs the open package on their own machine without network access and checks the mechanism on their own scenarios.
  2. Survey. A list is made of the agents, the systems they are connected to and the actions they perform. Irreversible actions are singled out.
  3. Admission rules. The organization’s policy is translated into admission rules that the security team reads and changes without changing program code.
  4. Observation. MITR is placed in the break between the agents and the systems in shadow mode: actions are not held up, decisions are recorded. After 30 days, the organization gets a report: what actions were taken, which would have been stopped, under which rule, and what the share of false stops is.
  5. Enforcement. Classes of irreversible actions, such as deleting data, payments and sending information outside the perimeter, are moved to enforce mode one by one, once the share of false stops has been determined for each.
  6. Operation. The receipts become material for internal audit and regulatory inspections. For significant objects of critical information infrastructure and closed environments, MITR is deployed in the customer’s infrastructure.
Market positioning and regulated-infrastructure case study
Jurisdiction Case Study · High-Regulated Critical Infrastructure

Regulation and critical information infrastructure case study

Using autonomous agents does not release an organization from the existing requirements for information protection. MITR helps meet them where the action is performed not by an employee but by an agent. The names of the acts are translated by the institute.

NormAddressed toHow MITR helps
Federal Law No. 187-FZ “On the Security of the Critical Information Infrastructure of the Russian Federation” and Order No. 239 of the Federal Service for Technical and Export Control of Russia (FSTEC of Russia)Subjects of critical information infrastructure: state bodies, institutions and Russian legal entities whose systems operate in healthcare, science, transport, communications, energy and the fuel and energy sector, atomic energy, banking and the financial market, state registration of real estate rights, and the defence, rocket and space, mining, metallurgical and chemical industries.An agent connected to a significant object acts within the admission rules, and each of its actions is recorded. This supports the measures for access management and security event logging.
FSTEC of Russia Order No. 117, in force since 1 March 2026Operators of state information systems, state bodies, unitary enterprises and institutions.The order sets requirements for the use of artificial intelligence for the first time. An admission rule can forbid transferring protected information outside the system without grounds, and the log records every decision.
Federal Law No. 152-FZ “On Personal Data”Operators of personal data, that is, practically every organization.An agent’s transfer of personal data to an external service is an action of the operator. An admission rule can forbid it without grounds, and the receipt records the grounds.
Bank of Russia Regulations No. 851-P and No. 757-PCredit institutions and branches of foreign banks (No. 851-P), non-credit financial institutions (No. 757-P).The actions of agents in the loop of financial operations are checked before execution and recorded.

The regulatory summary above was verified against the acts in force on 18 October 2026 and is an analytical reference rather than a legal opinion; an analysis of Order No. 117 is on the page FSTEC Order No. 117 and artificial intelligence.

Position in the market

  • What it is: an infrastructure layer of trust between the environment where an action is conceived and the environment where it is executed.
  • What it is not: MITR is not a second supervising neural network, a text filter, or a replacement for antivirus and network protection.
  • Who it is for: organizations that connect autonomous agents to their data, money and code and answer for their actions to clients, owners and the regulator. A private user does not need MITR: they set up their agents themselves and answer only to themselves.
  • Horizon: by 2027–2030, a large part of information exchange will move to the internet of agents: agents of different suppliers will call each other and the systems of organizations without a human. The less human there is in the chain, the more important a proof at every step becomes.
  • Neutrality: the proof does not depend on where the model comes from. MITR checks the actions of domestic and foreign, open and closed agents in the same way, and requires trust only in the rules the organization has set itself.
  • Who stands behind the method: the Autonomous Non-Profit Organization “Scientific Research Institute of System Synthesis”, the author of the method and the holder of the open code. Two invention applications have been filed, of 1 June 2026 for a method of verifying the actions of an autonomous software agent and of 22 September 2026 for a method of controlling its statements; no patent has been granted yet.

The market for protection tools for artificial intelligence systems in Russia has already taken shape, and what distinguishes MITR is the subject of the check: the action is checked, the decision is made by a solver, and an outside specialist re-verifies the receipt.

How MITR differs from known solutions

Checking an action against a rule did not begin with MITR: industrial authorization systems and research papers on protecting agents address it too. Below are the six solutions with which MITR is compared most often and the features in which they differ; each description is taken from the primary source named with it and was checked on 26 October 2026.

Matrix: six known solutions and MITR against five features: a proof for every action, facts from the organization’s sources, no language model in the decision, a receipt in a chain with an external timestamp, and formally proven properties of the rule language.Solution and primary source01A prooffor everyaction02Facts fromthe organization’ssources03No languagemodel inthe decision04A receiptin a time-stamped chain05Rule languagepropertiesprovenOpen Policy AgentOPA documentationCedarOOPSLA 2024ZelkovaFMCAD 2018, CAV 2022CaMeLarXiv, 2025AgentSpecICSE 2026ProgentarXiv, 2025–2026MITRpassport, 24–25 Oct 2026yespartlynonot describedMatrix: six known solutions and MITR against five features: a proof for every action, facts from the organization’s sources, no language model in the decision, a receipt in a chain with an external timestamp, and formally proven properties of the rule language.0102030405Open Policy AgentCedarZelkovaCaMeLAgentSpecProgentMITR01a proof for every action02facts from the organization’s sources03no language model in the decision04a receipt in a chain with an external timestamp05rule language properties formally provenyespartlynonot described
Partly: Open Policy Agent keeps a decision log, but without a chain; Zelkova applies a solver to a policy as a whole, and Progent only to changes of a policy; CaMeL tracks the provenance of data with capabilities, while a model writes the plan; AgentSpec rules and the Progent policy can be written by a model. Details and sources follow below.
  • Open Policy Agent (OPA) evaluates a policy written in the Rego language over the input of a request to a service, given in JavaScript Object Notation (JSON). It keeps a decision log with the input, the result and a decision identifier, and the description of that log names no hash chain and no external timestamp. Source: OPA documentation on decision logs.
  • Cedar evaluates an access request, that is, who acts, which action, on which resource and in which context, against a policy in the Cedar language. Its authors modeled the language in the Lean proof assistant, proved properties of the design on that model and give a sound and complete logical encoding for policy analysis; an evaluation returns an allow or deny decision without a receipt. Source: Cutler and co-authors, OOPSLA (Object-Oriented Programming, Systems, Languages and Applications) 2024, Digital Object Identifier (DOI) 10.1145/3649835; extended version arXiv:2403.04651.
  • Zelkova analyzes the access policies of Amazon Web Services themselves rather than a single request, for example whether a resource is open to everyone: a policy is translated into formulas, and satisfiability modulo theories (SMT) solvers check whether a property holds. In five years the number of solver calls grew from a thousand to a billion a day. Sources: Backes and co-authors, FMCAD (Formal Methods in Computer-Aided Design) 2018, 10.23919/FMCAD.2018.8602994; Rungta, “A Billion SMT Queries a Day”, CAV (Computer Aided Verification) 2022, LNCS (Lecture Notes in Computer Science) volume 13371, pages 3–18, 10.1007/978-3-031-13185-1_1.
  • CaMeL checks an agent’s tool calls against the control and data flows extracted from the trusted user query: untrusted data cannot change the flow of the program, and capabilities attached to data keep private data from leaving over unauthorized flows. On the AgentDojo set it solves 77% of tasks with provable security, against 84% without the defense; the paper does not describe a trace of each decision. Source: Debenedetti and co-authors, “Defeating Prompt Injections by Design”, arXiv:2503.18813, 2025.
  • AgentSpec enforces rules of a domain-specific language at run time, each made of a trigger, a predicate and an enforcement measure, with an overhead of milliseconds; the rules can also be written by a language model, and the paper does not describe a trace of each decision. Source: Wang, Poskitt and Sun, ICSE (International Conference on Software Engineering) 2026, pages 2938–2950, arXiv:2503.18666.
  • Progent checks each tool call, its name and its arguments, against symbolic least-privilege rules by a deterministic procedure. A language model writes the initial policy, and an SMT solver separates a narrowing of the policy, which is applied at once, from an expansion, which needs approval; the paper does not describe a trace of each decision. Source: Shi and co-authors, arXiv:2504.11703, versions of 2025–2026.
  • MITR checks an agent’s tool call together with facts that it takes from sources assigned by the organization rather than from the agent’s words. The solver Z3 (an open project of Microsoft Research) proves the admissibility of each action under a signed contract, with no call to a language model, and every decision leaves a receipt in a chain with an external timestamp, which an outsider recomputes and replays with their own tool. Source: the IS 3.0 verification passport, measurements of 24–25 October 2026.

What distinguishes MITR is three features taken together. The solver delivers a proof for each action, not for a policy as a whole, as Zelkova does, and not by plain evaluation of a rule, as Open Policy Agent and Cedar do. MITR takes the facts for the proof from sources assigned by the organization, and in this it comes closest to the separation of data flows in CaMeL. Every decision leaves a receipt in a chain with an external timestamp that an outsider recomputes without the developer: Open Policy Agent also keeps a decision log, but its description names no chain and no timestamp.

The comparison has another side as well. The Cedar language was modeled in the Lean proof assistant, whereas MITR’s code has not yet undergone formal verification, and a compact solver of the institute’s own with deductive verification of its code is in the work program. Zelkova and Cedar run at the industrial scale of a cloud provider, while MITR so far holds the actions of the institute’s own agents, and its first outside site will be a pilot at a customer.

Architect specification: Z3 QF_UFLIA solver, latency distribution, and boundary cases

For the security specialist and the architect: design, protocol, verification

This section is addressed to the head of information security, the information systems architect and the security engineer to whom the head of the organization sent this page. It sets out what exactly is checked, how MITR is connected, what it returns, how it behaves on failure and where the limits of its applicability lie.

What is checked

MITR checks not the model’s text but the tool call: the name of the action, the arguments, the recipient and the observed facts. The model’s reasoning is probabilistic and is not governed by rules; a call is discrete, so its admissibility is decided formally and before execution. Supervising one model with another is rejected by design: the supervising model has less variety than the one it supervises (Ashby’s law of requisite variety), and its verdict is itself probabilistic.

How a decision is made

  • An admission rule (contract) is a data file that sets out premises, a safety condition and a class of action. An SMT solver proves that, given the facts passed to it, the action does not violate the safety condition. If no proof is obtained, the action is not admitted. How such a proof works is explained on the page formal verification and the Z3 solver.
  • One of three modes is set for each class of actions: shadow (the decision is recorded, the action is not held up), advisory (the agent receives a warning) or enforce (an unproven action is not executed).
  • MITR’s answer contains the verdict and, on refusal, a list of the violated conditions of the rule and options for a fix. A receipt is attached to the answer with a sequence number and a hash linked to the previous record.
  • The vocabulary of recognized actions grows from the log of requests: a proposed rule is adopted only after a run on the body of earlier actions, through the same check and with a receipt. The first such rule entered the vocabulary on 25 September 2026.

Behaviour on failure

  • A failure of the check inside MITR leads to a refusal: the action does not pass even when it was an error that prevented the proof.
  • An action that the rules did not recognize is considered unproven. Since 24 October 2026, a default ban is active for such actions, and the request itself is sent for vocabulary review.
  • If MITR is unavailable for a class in enforce mode, that means a refusal, not a pass; since 24 October 2026, holding this rule at every connection point has been confirmed by the bypass probe.

Measured figures

What was measuredDate
A decision on one action in a warm process with 20 contracts in enforce mode takes 1.08 ms at the median (1.96 ms at the 95th percentile, 3.61 ms at the 99th), a self-correction call with an explanation takes 5.22 ms at the median, and a cold process start takes 30.7 ms (on 14 October 2026 with 19 rules, 0.95 and 4.26 ms; on 2 October 2026, 0.87 and 4.4 ms). On the internal adversarial set of 157 cases (114 attacks and 43 controls, prior to external accredited laboratory validation), no attack was missed and there were no false refusals.24 October 2026
Replay of decisions with an instrument designed for an outside verifier, an independent SMT-LIB solver over the texts of the rules stored next to the chain: in the historical anchor of epoch 33 (25 October 2026), 5,079 of 5,079 records matched with no discrepancies (on 14 October 2026, 4,958 of 4,958; on 3 October 2026, 2,814 of 2,820). As of 15 November 2026, the live receipt chain holds 5,373 records across 55 completed epochs (56 published). For regulated Russian banks and critical information infrastructure, OpenTimestamps proofs are paired with accredited trust service time stamps and qualified electronic signatures under Federal Law No. 63-FZ.25 October 2026
The head of the receipt chain is fixed once a day by an external time witness (OpenTimestamps); in the historical baseline of 25 October 2026 this was epoch 33 (5,079 sealed receipts, 5,094 chain length), and as of 15 November 2026 the chain holds 5,373 records across 55 completed epochs (56 published); integrity holds, and anchors and verifier are published openly. For Russian banking and critical infrastructure perimeters, OpenTimestamps is paired with accredited trust service time stamps and qualified electronic signatures under Federal Law No. 63-FZ.25 October 2026
MITR’s core has run continuously since 24 April 2026.24 April 2026
An admission rule is a data file: a new rule is added by editing the file, without rewriting the program.20 September 2026
MITR answers over the MCP protocol with token authorization.20 September 2026

The measurements were taken on the institute’s own environment, and the spread of latency under industrial load is determined on a joint test bench.

Connection

  • Over the MCP protocol: MITR connects as an ordinary MCP server; the address and token are issued at deployment.
  • Through an HTTP check call from the organization’s own code before the action is executed, with the same answer and the same receipt.
  • As a wrapper around the organization’s own MCP server, with the open package mcp-sentinel; the quick start is below.
  • With one import into a Python agent, with the open package iss-agent-kit.

Where the data are kept

The trial packages run entirely on the specialist’s machine: without a network, without an account and without contacting the institute’s servers. Where MITR is hosted at deployment is agreed with the customer; for significant objects of critical information infrastructure and closed environments, MITR is deployed in the customer’s infrastructure.

What is presented to an auditor

The auditor is given a sample from the chain of receipts: the action, the rule, the facts, the verdict and the time. The integrity of the chain is recomputed by an open verifier on the Python standard library, without installing the institute’s software. The anchors of MITR’s chain and the verifier are published at asi5.ru/console/verify/; the steps are on the page independent verification protocol.

Limits of applicability

  • MITR proves the admissibility of an action given the facts passed to it; the facts themselves are established by the customer’s sensors and systems. A wrong rule leads to a provably wrong admission, so the quality of protection is determined by the quality of the rules.
  • MITR does not check the model: the reliability of text, the quality of answers and backdoors in the weights are outside its subject.
  • The open packages check a call by pattern matching, without a solver; the solver and the chain of receipts with an external time witness are part of the full version of MITR.
  • The open package’s log: the chain detects editing, deletion, insertion and reordering of records; to also rule out a complete rewrite of the log by its owner, the head of the chain is fixed with an independent party.
  • MITR has no certificate of conformity. It is not required for protecting one’s own development environment; at significant objects of critical information infrastructure, the established procedure of software conformity assessment and system certification applies.

The internal design of MITR and its rationale, the classes of irreversibility, the checking loop and the invariants, are set out on the page MITR: architecture and rationale (in Russian).

What to check in an hour

  • The package is installed without network access, and it shows that a destructive database query is stopped; the commands are in the quick start below.
  • The organization’s own MCP server is wrapped by the package, and it shows what reason for a refusal the agent receives.
  • The package’s log is recomputed with the single-file verifier, and editing one record breaks the chain.
  • The anchors of the chain of the full version of MITR are recomputed from the data published at asi5.ru/console/verify/.
  • The limits of applicability are checked against the organization’s task, and questions this page does not answer are taken through the contact form (in Russian).
Apache-2.0 trial packages and Model Context Protocol (MCP) quick start

Trial packages: open code, no registration

A specialist installs the three open packages on their own machine in a few minutes, including without network access. Every file is certified with a checksum, and the source code is published.

mcp-sentinel: protecting MCP calls

A wrapper around an MCP server with four rules: limiting the file system to the working folder, forbidding destructive database queries, intercepting leaks of secrets, and a barrier against dangerous shell commands.

Open source · Apache-2.0 · mcp-sentinel 1.1.2

Installation package (.whl)

mcp_sentinel-1.1.2-py3-none-any.whl · sha256: 681a4db59a1a44e89a2b1386ec4b4f2e1fc23c1025c295b9ebf00fd5d20901ea

Source code (.tar.gz)

mcp_sentinel-1.1.2.tar.gz · sha256: abb88978db7b34a2f1f56e0eff42bcd1365b9cc0eb17e4a4380f7815e4f1b79e

Source code: https://git.isslab.ru/isslab/mcp-sentinel

Measurement: checking contracts in memory, median 0.015 ms; a full cycle including writing the decision to the log on disk, median 22.5 ms (N=100).

Engineering contradiction and theory of inventive problem solving (TRIZ) resolution: an agent must reason freely to solve complex tasks while every external action remains strictly bounded by safety rules. In MITR the model’s reasoning stays unconstrained while each discrete tool call is verified separately against declarative rules, returning the exact reason for any refusal so the agent can adjust its plan without repeating the forbidden call.

iss-ledger-117: a log under GOST R 34.11-2012

A log of decisions linked with the “Streebog” hash function, and a single-file verifier for an isolated machine.

Open source · Apache-2.0 · iss-ledger-117 1.1.1

Installation package (.whl)

iss_ledger_117-1.1.1-py3-none-any.whl · sha256: 8d4ffe60f41ebd377c476f369655aaef5e0ac91858a3d294be37fd1e3100bc87

Source code (.tar.gz)

iss_ledger_117-1.1.1.tar.gz · sha256: 6eccef523e24fa60fed29c78866ff12afbab092bd17d51642e00d34dfcea9fa5

Single-file verifier

iss_verifier.py · sha256: 1ff894574407307d33ec99115652bcaec4e53d06189178696d0db1c767a8608f

Source code: https://git.isslab.ru/isslab/iss-ledger-117

Measurement: the log passes the test examples of the description of the Streebog algorithm (RFC 6986), and the single-file verifier works in an isolated environment without a network.

The contradiction: an audit log must carry evidential weight for the regulator, and it must not depend on closed trust servers and external suppliers. The TRIZ resolution: a chain of receipts under GOST R 34.11-2012 in pure Python with no dependencies; its integrity is recomputed by a single-file script in an isolated environment, without trusting the developer.

Quick start: connecting protection to an existing MCP server

A vulnerable MCP server is not started directly; it is wrapped in mcp-sentinel wrap, and every tool call is checked before it runs, and the server’s response before it is passed to the agent. The package is written in pure Python with no third-party dependencies and installs without network access.

Installation

# isolated environment: the .whl files were downloaded in advance, no network needed
pip install --no-index --find-links ./wheels mcp-sentinel
# with network access: the institute's index only, PyPI is not queried
pip install --no-index --find-links https://isslab.ai/wp-content/uploads/iss-utils/index.html mcp-sentinel

Client configuration: the mcpServers section of the settings file of the agentic development environment. The database credentials in the sample are taken from environment variables, and their values come from the secrets store of the organization. The open package holds no keys: it is a wrapper around a server to which the organization itself issues credentials, and the property “keys only inside MITR” belongs to the full version of MITR installed at a customer. The log is written to a directory available to the agent process.

{
  "mcpServers": {
    "postgres-secure": {
      "command": "mcp-sentinel",
      "args": ["wrap", "--ledger", "/home/dev/.local/state/mcp-sentinel/audit.jsonl", "--agent", "dev-agent", "--",
               "npx", "-y", "@modelcontextprotocol/server-postgres", "postgresql://${PGUSER}:${PGPASSWORD}@localhost/prod"]
    }
  }
}

Checking one call from the console

mcp-sentinel check --tool sql_query \
  --args '{"query": "DROP TABLE users;"}'
# BLOCK: the destructive DROP TABLE operation is stopped, exit code 2

A Python agent: connected with one import, the iss-agent-kit package

from iss_agent_kit import AgentGuard
guard = AgentGuard(ledger_path="audit/agent_gost.jsonl")
result = guard.run(execute_sql, "sql_query", {"query": "SELECT id FROM users WHERE id = 1;"})

Open source · Apache-2.0 · iss-agent-kit 0.1.1

Installation package (.whl)

iss_agent_kit-0.1.1-py3-none-any.whl · sha256: 7ed0ae9073f512a5cfd71b62904094ca36d0ae2fdb1b4bfff5900d3e368781c3

Source code (.tar.gz)

iss_agent_kit-0.1.1.tar.gz · sha256: 0314047404888c29a231fc8710874f15bc2bd75e2b89ba7c4c882da3c792116a

Source code: https://git.isslab.ru/isslab/iss-agent-kit

The commands in this section are run when each version is accepted, in a clean environment without a network, with the same lines as printed here. The log at the --ledger path is kept as a chain under GOST R 34.11-2012 and recomputed by an external verifier without installing anyone else’s software.

Zero-Cookie Sovereign Intake · Direct Delivery to Scientific Director

Configure a 30-day MITR pilot or architecture review

Select the engagement track and enter a work address to submit a structured engineering or diligence brief directly over Transport Layer Security (TLS) to isslab.ai. Zero cookies and zero third-party processors are involved; details are published in the privacy policy.

Related pages