How Standard works
Where your function runs, and what governs it
Put your calculations, validations and decision logic into approved functions. Standard runs the accepted Wasm workload on protected inputs under the required owner permissions and release rules, then returns permitted results with Standard Proof. Planning and orchestration stay in your applications and agents.
Architecture
Where your function runs
Your approved function contains the calculations, checks and failure behavior. Customers control its accepted revision, supported sources, keys and API secrets. Standard retrieves and validates authorized inputs, runs the accepted function in confidential execution and releases permitted results with Standard Proof.
- Protected datasupported connected source or locally encrypted contribution
- Participant-held signing keyssign its own approvals and release authorizations
- Customer-controlled vaults and key storespersistent custody of keys and API secrets; scoped access for permitted work
- Its policies and trust referenceswhich profile may use its data, and what it receives
- Approved Wasm workloadencrypted by the code owner before contribution
- Participant-held signing keyssign its own approvals and release authorizations
- Its policies and trust referenceswhich revision runs, and what it receives
- Caller identity and scoped authority
- Approved function and policy snapshots
- Scheduling, quotas, and lifecycle
- No ordinary plaintext protected inputs
Outside the TEE: checks each request against every required owner’s authority before anything runs.
- Assurance teamthe permitted findings, decrypted with keys it holds
- Customer and vendortheir own permitted outputs, such as findings or a service summary
- Receiving integrationVerify execution evidence → evaluate the result → enforce next-action policy
The receiving integration verifies Standard Proof against the references it already trusts before the result is accepted. It runs in the recipient’s trusted environment, outside the protected execution boundary, and the workflow blocks there when verification fails.
External tools stay outside the attested boundary. Source endpoints and authorized result recipients remain separate trust boundaries.
A restricted interface for the approved function
The function reads declared inputs and produces declared output candidates within configured limits. It receives no general shell, filesystem, subprocess, or network interface.
Supported source retrieval happens separately under scoped permission. Connecting a data source does not give the function unrestricted network access.
Function requirements
What your function needs
- Customer-defined logic
- Implement the calculations, required checks and failure behavior in a supported WebAssembly function. Accept its workload revision outside the requesting agent’s authority.
- Compatible inputs
- Use the module’s accepted input format through local encrypted files or a supported connected source. Confidential ingress validates connected-source material before contribution.
- Declared limits
- Set the memory tier, concurrency, per-call time limit, and fuel, input, output and import bounds. Confirm the fit before adapting your function.
- Permitted result
- Define the allowed output and recipient in advance; the computed values are produced during execution.
Owners configure the scope during setup and approve operations when they are requested; Standard checks current authority for every operation.
Managed operation lifecycle
Set up the function. Verify each operation.
Establish the accepted function, participants and permissions during setup. Routine requests use that configuration, while Standard checks the current authority and exact inputs for each operation. Connection verification and approval-time snapshots can read under separate scoped permissions before final operation approval.
Initial setup
- Function and profile
- Implement the business logic and failure behavior, then accept the function revision, input and rule formats, execution limits and permitted outputs.
- Participants and authority
- Establish the required owners, caller and recipient identities, approval requirements and release rules.
- Contributions and verification
- Connect supported sources and configure scoped access. Keep persistent control of keys and API secrets in your own vaults or key stores, and establish the recipient’s independent trust references.
Each operation
The Analytics agent requests conversation-categories for batch-042. The approved batch, classifier and Analytics integration are fixed by the accepted operation; the request cannot expand them.
Temporary execution state is cleaned up according to the runtime lifecycle. Results, retained evidence and Space configuration have separate lifecycles.
Cleanup and retention →Approved functions
Define the work. Keep each owner in control.
The function contains your business logic. The operation profile binds the accepted program, input roles, limits and permitted outputs. Each required owner authorizes the use of its assets and result release.
- 1The profile declares roles, slots and outputs
- 2Each owner authorizes its own contribution
- 3Standard enforces the approved scope
Scoped authority
A Space defines who can run what and what may leave
Start with one organization. Add owners only when the function needs their assets or approval.
| Participant | Contributes | May authorize | Receives |
|---|---|---|---|
| Input owner | ContributesApproved classifier and batch-042 | May authorizeClassification and permitted-result release | ReceivesWhat the release rules permit |
| Analytics integration · recipient | ContributesNo private input | May authorizeIts own publication decision | ReceivesCategory counts or failure report + Standard Proof |
| Sponsor | ContributesPayment for the operation | May authorizeNothing over another owner’s assets | ReceivesUsage and billing records |
Being invited, signing in or paying does not, alone, authorize execution, asset use or result release.
Security and plaintext boundaries
Where protected inputs and permitted results can be seen
Attested confidential ingress retrieves and validates authorized material. The operation worker processes bound inputs within its attested boundary. Permitted credential use stays within the appropriate confidential components.
| Location | Intended visibility |
|---|---|
| Data or code owner’s environment | Intended visibilityIts own source inputs, workload and keys, under that owner’s custody. |
| Requesting agent | Intended visibilityAuthorized references and permitted outputs. Protected source inputs need not enter the agent’s context. |
| Standard’s coordination services | Intended visibilityAccount, permission, status and usage metadata, together with protected-input references. Routine coordination is not a plaintext path for protected inputs. |
| Protected storage and transit paths | Intended visibilityEncrypted contributions and protected results, according to the supported contribution and delivery protocols. |
| Attested confidential components | Intended visibilityPlaintext required by the trusted host, approved workload and release logic while processing. Confidential ingress may use transient data keys or API secrets; non-exportable master keys stay in the customer’s key store. |
| Authorized recipient | Intended visibilityIts permitted output, decrypted with keys it holds in its own environment. |
What the service enforces
Confidentiality, authority, limits, and proof
- Caller identity and scoped authorityThe agent’s accepted identity and current permission to request the exact function, inputs, and result.
- Approved workload and limitsThe exact Wasm revision and its memory, fuel, time, input, output, and import bounds.
- Attested confidential runtimeHardware-backed protection for plaintext inputs while the approved workload runs, with managed startup and cleanup.
- Permitted result and Standard ProofRelease rules govern what reaches each recipient; signed evidence binds the operation the receiving integration verifies before accepting the result.
- Account access
- Permission to contribute
- Permission to execute
- Permission to release
Account access, permission to contribute, permission to execute and permission to release are separate checks. Passing one does not satisfy another.
Security boundary
The requesting agent does not control the approved function
Standard separates who requests an operation from who authorizes it, which protected inputs it may use, which workload and limits apply, what may be released, and what the receiving integration verifies.
Who speaks for each owner?
An accepted identity, acting under bounded delegation and signed authority. Delegations can be revoked, and authority must be current when it is used.
Who can approve an operation?
Each required owner, independently. Sponsoring a Space or inviting a participant does not transfer control of anyone’s assets.
What can leave?
Only permitted results may be released, and only to permitted recipients. Execution success alone is not release permission.
What can the next system verify?
Signed, checkable evidence for the exact operation, under trust roots it accepted. Verification does not confer new permissions.
What is not covered?
Correct answers, true inputs, complete secrecy of metadata, erasure of copies an authorized recipient keeps, the integrity of arbitrary external backends, and regulatory certification without certification evidence.
Independent parties still rely on accepted hardware, runtime, workload and policies, secure keys, correct verifiers and references, and their own endpoint custody, as the security model sets out.
Standard Proof
Verify the exact operation and permitted result
Standard Proof binds the recorded execution environment, the approved function and its profile, the exact inputs, the owner approval that applied, and the released result. Your receiving integration checks those bindings against the references and policy it already trusts before using the result.
- Expected profileaccepted profile revision
- Owner authorityeach required owner, for this workload and result
- Input bindingexpected input digests
- Accepted runtimeattested TEE measurement
- Result and releasepermitted result digest · intended recipient
- Evidence accepted
- Evaluate the findings against your policy
- Apply your own policy for what happens next
Valid evidence is not permission. Your own authorization still decides the next action.
| Check | Required relationship |
|---|---|
| Runtime | Required relationshipThe evidence-signing identity must be bound to the accepted runtime, with current attestation and revocation checks. |
| Workload and profile | Required relationshipThe recorded workload and profile revisions must match those accepted for the operation and be bound to the execution evidence. |
| Inputs | Required relationshipThe recorded input digests must match the expected artifacts or snapshots used by the operation. |
| Authority | Required relationshipRequired permissions must cover the applicable asset use, execution and release under the relevant validity rules. |
| Result and recipient | Required relationshipEvidence must bind the exact released result to its intended recipient and permitted release context. |
| Signature and references | Required relationshipSigned evidence must validate under references and policy established independently of the candidate result. |
Input bindings identify the artifacts or snapshots used. Source provenance uses source records included in the operation’s verification contract.
Verify the evidence, evaluate the result, and check authority for the next action. A valid proof does not grant permission for that next action.