Threat model and AI risk mapping
How Standard’s execution controls and approved customer functions address specific threat scenarios using MIT’s risk and mitigation taxonomies.
This is Standard’s assessment using the MIT AI Risk Repository and the draft taxonomy in the MIT AI Risk Mitigation Map, reviewed on November 8, 2026.
The assessment covers the Conversation analytics threats, including attempts to skip or substitute required checks. It distinguishes protections provided by Standard’s execution and authority controls from checks implemented in approved customer functions.
Risk references identify the failure being addressed. Mitigation references identify the type of control applied. These are separate taxonomies, and the mappings below are Standard’s interpretation of the specific mechanisms described.
For example, Risk 2.2 concerns AI system security vulnerabilities and attacks; Mitigation 2.2 concerns Model Alignment.
The homepage demonstrates conversation-categories over the approved batch-042 selection: 1,000 conversations, with permitted category counts sent to the Analytics integration. The classifier and any model it uses execute inside the protected runtime. See Conversation analytics for the function and its duplicate-ID failure report. Software release verification remains a separate documentation example.
These scenarios describe the declared boundaries. Component tests do not establish a completed deployed customer transaction; current readiness is a separate evidence question. Standard Proof does not establish classification accuracy or source truth. Permitted aggregates can reveal information, and approved recipients can misuse results after receiving them. Owners must choose appropriate functions, outputs and query limits.
Two sources of risk mitigation
Standard’s execution and authority controls
Standard binds the accepted workload and inputs to the protected operation, enforces owner permissions and execution limits, protects sensitive processing, and controls result release. Standard Proof provides evidence the receiving integration verifies against independently accepted references before use.
Customer-defined logic
Customers can implement deterministic calculations, validations and decision rules inside approved functions. The function contains the required checks and defines their outcomes and failure behavior. Standard enforces execution of the accepted workload within the operation’s authorized boundaries.
The requesting agent cannot substitute a different function or broaden the accepted scope through its request. The function author remains responsible for implementing the intended checks across the relevant code paths.
| Mechanism | MIT mitigation category | Where the mitigation comes from |
|---|---|---|
| Confidential execution and protection against unauthorized access or tampering | Mitigation 2.1 — Model & Infrastructure Security | Standard’s execution controls, within their documented boundary |
| Restricted capabilities and enforcement of the accepted execution plan | Mitigation 2.3 — Model Safety Engineering | Standard’s capability and execution restrictions |
| Owner-scoped permission to use resources and release results | Mitigation 3.3 — Access Management | Standard’s authority and release controls |
| Required validation or evaluation checks | Mitigation 3.1 — Testing & Auditing | Checks implemented in the approved customer function; accepted execution enforced by Standard |
| Specific data-quality, privacy or permitted-use checks | Mitigation 3.2 — Data Governance | Applicable when the approved customer function implements the relevant check |
These mappings describe specific contributions to the mitigation categories. Customer-defined coverage depends on the checks actually implemented in the approved workload.
Standard Proof supports verification of the recorded execution and result. “Execution accountability” describes that contribution; it is not a separate MIT subcategory.
Protected flow and custody
The Sources and customer vaults guide explains the input routes and customer-controlled access behind this comparison.
- Customers connect supported sources and retain persistent control of keys and API secrets in their own vaults or key stores.
- Customers grant scoped access to selected resources and approve permitted work. Connection verification and approval-time snapshots have separate scoped permissions and can precede final operation approval.
- Attested confidential ingress checks the signed grant, owner approval, connection, selector, version and required input bindings. It retrieves the authorized material and verifies retrieved bytes before contribution to the operation worker.
- Sensitive processing and permitted credential use occur in the appropriate confidential components. Ingress uses permitted API secrets to call the approved source. The operation worker executes the accepted customer function on the bound inputs within its attested boundary and granted interfaces. That function implements the operation’s calculations, required checks and failure behavior.
- Release rules govern the result and recipient. The receiving integration verifies supported claims using Standard Proof against independently accepted roots and expected operation references, then applies its own next-action policy.
For supported vault and KMS connections, non-exportable master encryption keys remain in the customer’s key store. Decrypt or sign operations use those keys there. Transient data keys and API secrets can exist in confidential memory for their permitted use.
Raw protected material is designed to stay out of the requesting agent and Standard’s coordination services. It can exist at customer/provider source endpoints, inside the appropriate confidential components, and at authorized endpoints for permitted results. References, resource names, status and other operational metadata are outside that protected-content boundary. The Analytics integration receives the permitted result, not the underlying conversations or source credentials.
Controls and supporting evidence
The summaries below describe the implemented controls and the behavior covered by existing supporting tests.
Standard Proof verifies recorded workload and input digests, owner authority, execution evidence, result digest and permitted recipient/release bindings through the delivered evidence contract. Recipients compare those records with independently trusted expectations.
Connection checks authenticate the approved source and selection internally. Recipient verification of a source claim uses an authenticated source record included in the delivered verification contract. Input digests bind the conversation batch bytes to the operation and result.
Prompt injection
Threat and MIT risk: A poisoned document tells the Analytics agent to send the full conversation history to an outside address. Privacy compromise (Risk 2.1) and system-security attacks (Risk 2.2).
Control and enforcement: Owner-approved scope constrains source, operation, credential use and recipients. Request admission checks authority; confidential ingress checks the exact resource grant and owner approval; the worker and release path enforce their respective contracts. The agent can request the operation with references without holding raw customer credentials.
Implementation and test coverage: Signed grants and owner approvals are verified before source access. Existing component tests cover invalid approval, denied requests before credential use, and requests that authorize no connection.
Recipient verification: Standard Proof binds the recorded operation, authority, inputs, result and recipient. The receiving integration verifies the expected operation and release scope before use.
Exposed agent environment
Threat and MIT risk: An intruder reads the Analytics agent’s memory, traces or logs. Privacy compromise (Risk 2.1), with system-security attacks (Risk 2.2) as the access mechanism.
Control and enforcement: Local-file preparation is performed by the participant host. Connected-source retrieval uses confidential ingress and customer-store access rather than passing raw conversation data or credentials through the agent. Agent-facing requests carry source and secret references and status. The authorized Analytics integration verifies the permitted category counts before making them available to the Analytics agent.
Implementation and test coverage: Confidential ingress manages retrieval and credential lifetime, with scoped credentials obtained from the configured provider. Existing component tests cover refusal before credential use, input validation before contribution, agent-facing command handling and hosted metadata delivery.
Recipient verification: Standard Proof verifies the report’s supported execution and release bindings.
Altered result
Threat and MIT risk: Category counts change after execution and before the analytics workflow uses them. System-security attacks (Risk 2.2).
Control and enforcement: The receiving client verifies signed execution/release evidence, expected references and the result digest before accepting or decrypting the result. Result evaluation and publication authorization remain separate decisions.
Implementation and test coverage: The receiving client assembles and verifies execution and release evidence. Existing component tests cover fabricated evidence, expired authority presented for a first receive, and recipient-side command handling.
Recipient verification: Standard Proof binds the result bytes to the recorded operation and permitted release. Changing a bound field or result must fail verification against trusted expectations.
Skipped or substituted required checks
This additional case uses the separate software release verification example.
Threat and MIT risk: An agent presents a different function, weakened checks or an unverified report as though the owner-approved validation had run. The primary mapping is Risk 2.2, for unauthorized substitution or circumvention of the accepted verification process.
Control and enforcement: The owner accepts the function and operation boundaries independently of the requesting agent. Standard binds the accepted workload, relevant inputs and configuration to the protected operation and rejects substitutions that differ from the authenticated plan. Required business checks must be implemented in the approved function; the agent’s request does not authorize replacing that function or changing its accepted scope.
MIT mitigation connection: The accepted validation workload supports Mitigation 3.1. Standard’s execution and authority restrictions support the applicable elements of Mitigation 2.3 and Mitigation 3.3.
Implementation and test coverage: The execution-plan path binds the accepted workload, inputs and configuration to the protected operation and rejects local specifications that differ from the authenticated plan. Existing component tests include cases for a substituted program, changed step contracts, altered configuration selections and missing or extra program/gate artifacts.
Recipient verification: The recipient verifies the expected workload, candidate and result bindings, then evaluates the reported check outcomes. A report produced by different checks must not satisfy the expected verification policy. A valid Standard Proof may accompany a report containing failed checks. An external deployment must require the expected verified outcome through its own integration.
Scope: Standard enforces the accepted function and execution plan. The function author defines the checks and their behavior; the runtime does not independently establish that arbitrary customer code implements every intended business requirement correctly.
Unexpected code behavior
Threat and MIT risk: A classifier dependency attempts to read unrelated files or contact an outside endpoint. System-security vulnerabilities and attacks (Risk 2.2); privacy compromise (Risk 2.1) if access exposes private material.
Control and enforcement: The Wasm workload receives declared interfaces and resource limits. It does not inherit the agent’s filesystem, shell or credentials. Ingress’s permission to use a source credential does not confer that capability on the workload.
Implementation and test coverage: The execution runtime enforces declared workload interfaces. Existing component tests exercise input/output interfaces, capability restrictions, credential access and process limits.
Recipient verification: Standard Proof lets the recipient compare the recorded workload and execution references with its accepted versions.
Exposed execution host
Threat and MIT risk: An attacker with hosting-infrastructure access outside the attested runtime tries to inspect conversations during processing. Privacy compromise (Risk 2.1) and system-security attacks (Risk 2.2).
Control and enforcement: Attestation gates acceptance of confidential ingress and the operation worker. Protected sessions carry validated contributions to the worker; the approved function processes the approved conversations inside its confidential boundary. Customer-store credential release uses the supported provider’s configured enforcement.
Implementation and test coverage: Confidential ingress, scoped credential retrieval and protected worker sessions enforce these boundaries. Existing component tests cover attestation refusal, startup without attestation, and provider-specific image conditions.
Recipient verification: Standard Proof supports checking the recorded execution environment against accepted attestation roots and measurements.
Reused approval
Threat and MIT risk: An approval for batch-042 is presented for batch-043 or an unapproved recipient. System-security attacks (Risk 2.2).
Control and enforcement: Admission and participant-action checks bind authority to the operation and exact input/release contract, enforce expiry and consumption, and refuse mismatched grants. A standing permission for one exact task is separate: explicit per-host opt-in, off by default, same inputs, recipients and release rule, no connected sources, at most 100 runs over at most 30 days, revocable when Management records revocation.
Implementation and test coverage: Grant validation binds access to the authorized action and its lifetime. Existing component tests cover invalid signatures, expired or mismatched grants, replay and restart behavior. Database policy tests cover the separate bounded standing-permission model.
Recipient verification: Standard Proof lets the recipient verify the recorded authority and operation/release bindings. Current-authority checks and consumption are enforced when authority is used.
Unapproved or substituted input
Threat and MIT risk: The classification request names an unapproved dataset, or the retrieved batch differs from the owner-approved version. System-security attacks (Risk 2.2); privacy compromise (Risk 2.1) when an unauthorized resource would be read.
Control and enforcement: Before retrieval, confidential ingress verifies the signed grant delivery against the leased action and owner approval: connection, resource selector, pinned version and required slot, digest and byte-length bindings. The resource adapter confines access to the supported target. After retrieval, confidential ingress compares the bytes’ digest and length with the bound expectations. A mismatch contributes nothing to the operation worker. Approval-time snapshots use separate scoped permissions before final operation approval.
Implementation and test coverage: Grant, approval and resource validation enforce the selected source and input bindings. Existing component tests cover agreement between issued grants and consuming components, rejected deliveries, digest mismatches that contribute no input, and fresh query responses checked against approved snapshots.
Recipient verification: Standard Proof can bind the expected conversation-batch digest to the operation and result. Connection identity, resource selection and provider version are checked internally; recipient source verification uses source records included in the delivered contract.
How additional customer checks are assessed
An additional risk mapping must identify:
- The specific failure being addressed.
- The check or constraint implemented in the approved function.
- The accepted workload and relevant input or configuration bindings.
- The behavior when the check fails.
- Evidence that the check and its enforcement behave as intended.
The Conversation analytics reference function rejects duplicate conversation IDs before calculating category counts. This addresses a defined input-validation failure in that workflow. It would not establish that the source conversations are truthful or that every form of false information is prevented.
The ability to run customer code is an enabling capability. Risk coverage is attributed to the specific implemented check and its enforced use.
Provider configuration
Supported adapters include object storage and bounded query sources; availability depends on the configured connection family and execution path. Object storage uses a provider-specific version identifier. Query sources use a saved query, bounded time range and approved snapshot digest. Retrieved bytes are checked against the approved snapshot.
Customer-store adapters differ in authentication, credential lifetime and attestation enforcement. For Azure, Standard checks the owner-accepted image condition and records provider-side image enforcement as false. AWS, Google Cloud and Vault integrations require their own configured trust, roles and conditions. Participant-host custody remains a separate route.
See the security model, verification checks and integration reference for the operation and verification contracts.