FAQ
Managed confidential execution, clearly explained
What Standard runs, how it differs from a gateway or sandbox, why functions run in Wasm, and how the next step knows it can use a result.
Standard is a managed confidential execution service. Customers put calculations, validations and business rules into approved functions. Standard runs the accepted Wasm workload on protected inputs, enforces each owner’s permissions and release rules outside the caller, and returns permitted results with Standard Proof.
An agent gateway governs requests to tools and services; a Linux sandbox provides an isolated environment for running code. Standard executes an owner-approved function through restricted Wasm interfaces inside a confidential runtime. It enforces the operation’s permissions and release rules, then provides evidence the receiving integration verifies before accepting the result. Gateways and sandboxes can remain part of the surrounding stack.
Standard gives the function a deliberately small interface: declared inputs, named outputs, and bounded execution. It does not expose a general shell, filesystem, subprocess, or network interface. This limits the capabilities available to faulty or malicious code. Functions must fit that interface, so existing code may need adaptation.
You configure the receiving integration with the expected operation and independently accepted verification references. It checks Standard Proof before accepting the result, and missing or mismatched evidence blocks acceptance. Your workflow separately evaluates the result and enforces authority for the next action. These requirements apply when the same agent continues its work and when the result passes to another agent or service.
Approved Wasm functions implementing calculations, validations, decision rules and report generation within the supported memory, fuel, duration, input, output and import limits. Examples include sales totals, artifact validation, private data analysis and model scoring with compatible inputs. The function defines the required checks and how their outcomes are reported.
Use a supported connection or prepared file. Standard retrieves and validates the permitted inputs, then supplies them to the function without giving it unrestricted network access. See Sources and customer vaults for the supported input routes.
No. Your agents keep running in their existing environments. They call Standard through MCP, the SDK, or the CLI for the bounded functions that need confidential execution, controlled release, or verifiable evidence.
Yes. You provide an approved function containing the calculations, validations and decision rules you express in code. The function uses Standard’s supported workload interface and execution limits. Standard binds the accepted workload and inputs to the protected operation and enforces owner permissions and result-release rules.
Put those checks inside the approved function and establish the accepted workload revision outside the requesting agent’s authority. The agent requests the operation against that accepted code and scope; substituted code or broadened scope is refused. When a later action depends on the result, the receiving integration requires the expected evidence and outcome before allowing it.
Yes. Standard manages admission, attestation, confidential input handling, workload activation, resource enforcement, result release, Standard Proof and cleanup. You define the function’s business logic, checks and failure behavior, and configure its inputs, limits and required permissions.
Supported sources remain under customer control. Attested confidential ingress retrieves and validates authorized material, and the operation worker processes it. Raw protected material stays out of the requesting agent and Standard’s coordination services. Source endpoints and authorized result recipients remain separate trust boundaries.
For supported vault and KMS connections, your non-exportable master encryption keys remain in your own store. Standard’s authorized confidential components may use temporary data keys and connector credentials to process permitted inputs. Protected input contents stay out of the requesting agent and Standard’s coordination services.
Standard separately checks caller identity, required owner authority, the accepted workload and release conditions. Attestation identifies the accepted execution environment. Your receiving integration verifies Standard Proof against independently accepted references before accepting the result. Your workflow then evaluates the outcome and enforces permission for the next action.
It lets a recipient verify the recorded workload, relevant inputs and permissions, accepted runtime, and result and release evidence against the references it already trusts. The receiving system applies its own acceptance and next-action policy.
No. Your receiving integration checks Standard Proof automatically against its accepted trust references and the expected operation before accepting the result. Missing or failed required evidence checks block acceptance. Your application separately evaluates the findings and decides whether the next action is authorized.
A Space brings together the participants, permitted operations, contributions, and release rules for a workflow. Membership does not by itself grant access to private inputs or permission to run every operation.
An operation profile binds the accepted function, roles, inputs, limits and permitted outputs. The function contains the business logic; the profile defines its accepted execution boundaries; each required owner authorizes asset use and result release.
No. Start with one organization and one agent function, such as a private data analysis or verified agent handoff. The same Space model can add independent owners when a function needs their assets or approval.
No. Paying, inviting, authenticating or coordinating does not create authority over another owner’s protected assets. Each required owner must supply accepted authorization for the permitted use and release.
No. Participants retain control of their own credentials and protected assets, and each signs its approvals and release authorizations with keys it holds. The accepted execution can process only what they authorize, and private material is not exposed as general agent context.
By default, yes. Each required owner approves each operation when it is requested. An owner can opt in, per host, to a standing permission that repeats one exact task (same inputs, recipients and release rule; no connected sources; at most 100 runs over at most 30 days), revocable from the Space page; it never stands in for another owner’s approval. Requests without current approval are blocked.
Yes. The operation profile defines each permitted output and who may receive it. In vendor diagnostics, the customer receives detailed findings while the vendor receives a narrower service summary. Each release still needs the applicable owners’ permission, and no recipient receives more than its output allows.
The result is not released to that recipient under that request. Successful computation never overrides a missing required release permission.
No. Connecting an agent does not give Standard access to your files, credentials, or other private data. Protected inputs must be prepared and authorized separately, and private inputs do not travel through MCP.
Calling an existing external API does not, by itself, require its provider to join Standard. A vendor that contributes protected code or authorizes its use participates as an independent owner in the operation. Calling a provider’s API, or having that provider participate, does not bring its external backend inside Standard’s attested execution boundary.
Use protected execution when a workload must process private inputs or when the recipient needs evidence about the exact workload and runtime. The attested hardware-backed TEE keeps the operation out of reach of ordinary host and operator access. Recipients use hardware attestation to check the runtime against their accepted references.
No. It establishes what the execution evidence covers: which function ran, on which inputs, under whose approval, in which runtime, and what was released. The next step must verify the evidence and apply its own acceptance rules to the result.
Sign in with your own account and accept the invitation. You keep your own credentials and signing keys, and you authorize only your own contribution and the results that depend on it. The sponsoring organization pays for the execution it sponsors; you don’t need your own paid plan to participate.
Request access for one bounded agent function. Describe its workload, protected inputs, limits, permitted result, and recipient. Contact Standard for a usage-based proposal.