Standard
  • Docs
  • Examples
  • Pricing
  • About

Get started

  • Overview
  • How Standard works
  • Run your first task
  • Connect
  • Join a Space

Build

  • Examples
  • Operation profiles
  • Integration reference

Concepts

  • Inputs and permissions
  • Accounts and billing
  • Results and lifecycle
  • Verification checks
  • Follow-on tasks
  • Cleanup

Security

  • Security model
Documentation menu

Get started

  • Overview
  • How Standard works
  • Run your first task
  • Connect
  • Join a Space

Build

  • Examples
  • Operation profiles
  • Integration reference

Concepts

  • Inputs and permissions
  • Accounts and billing
  • Results and lifecycle
  • Verification checks
  • Follow-on tasks
  • Cleanup

Security

  • Security model
Standard

Managed confidential execution for sensitive functions.

© 2026 Standard Runtime, Inc. All rights reserved.

  • Security
  • Docs
  • Examples
  • Pricing
  • FAQ
  • About
  • Contact
  • Terms
  • Privacy
  • Cookies
  • Docs
  • Examples
  • Pricing
  • About
  • Get started

    • Overview
    • How Standard works
    • Run your first task
    • Connect
    • Join a Space

    Build

    • Examples
    • Operation profiles
    • Integration reference

    Concepts

    • Inputs and permissions
    • Accounts and billing
    • Results and lifecycle
    • Verification checks
    • Follow-on tasks
    • Cleanup

    Security

    • Security model

    Get started

    • Overview
    • How Standard works
    • Run your first task
    • Connect
    • Join a Space

    Build

    • Examples
    • Operation profiles
    • Integration reference

    Concepts

    • Inputs and permissions
    • Accounts and billing
    • Results and lifecycle
    • Verification checks
    • Follow-on tasks
    • Cleanup

    Security

    • Security model

    Run your first task

    Start with one organization and an approved Wasm function, set authority and release rules, and verify the permitted result.

    Example: a coding agent submits a release candidate for approved checks. The release owner controls the verification workload and release rules. The release agent receives the permitted report with Standard Proof before deployment continues. The steps below use the CLI; the SDK and MCP send the same operations through the same authorization and execution path.

    Agree the function and setup

    Start with a request for access. Bring a description of the checks, a non-sensitive example of the candidate format, the intended recipient and your operating requirements. We’ll help assess the Wasm interface, input preparation, resource limits and recipient verification, then agree the setup and next steps.

    You provideStandard helps configure and operates
    Validation code and accepted candidate formatThe supported Wasm interface, accepted workload revision and execution limits
    Release owner, candidate scope and permitted recipientThe configuration that binds those identities and checks their current authority
    Participant-side encrypted-input preparation and owner-controlled key accessThe confidential execution path, activation and result-release enforcement
    Recipient verification references and deployment policyEvidence for the operation; your recipient integration verifies it in your environment

    Confirm duration, memory, fuel, input and output size, import restrictions, expected latency and available capacity before committing to integration. An existing function may need adaptation to the supported Wasm interface. The accepted output contract defines allowed fields and recipients; it does not precompute the result.

    1. Create the Space

    The sponsoring organization creates the reusable Space and pays for the execution it sponsors. The release owner, coding agent and release agent can belong to one organization while holding distinct responsibilities. Sponsoring or signing in does not grant execution or release permission. See Accounts, Spaces and billing.

    2. Deploy the function and its profile

    For this example, the approved validation function runs a fixed set of checks against one candidate artifact and reports each outcome. It accepts a candidate archive with a manifest of its files and their digests. The release owner accepts the exact input format, workload revision, candidate scope, limits and output fields during setup.

    Example candidate manifest, prepared in the owner’s environment:

    json
    {
      "artifact": "service-api-2.14.0.tar.gz",
      "files": [
        { "path": "bin/service-api", "sha256": "4e1a…9c02" },
        { "path": "config/defaults.toml", "sha256": "b71d…3e55" }
      ]
    }
    PreviousHow Standard worksNextConnect

    On this page

    • Agree the function and setup
    • 1. Create the Space
    • 2. Deploy the function and its profile
    • 3. Authorize
    • 4. Run
    • 5. Receive and verify the result
    • Handle refusals and failures
    • Add owners when the function needs them

    The operation profile names the roles, the input slots, the output contract and the limits. Operation profiles describes each part; How Standard works shows the release example with every field highlighted. Publish the function with its profile from the CLI:

    bash
    standard deploy ./release-checks.wasm --profile profile.json

    The same call from code is standard.deploy('./release-checks.wasm', { profile: 'profile.json' }). Publication records the accepted workload revision and profile revision; nothing runs yet.

    The coding agent cannot substitute a different function, change the accepted checks or request arbitrary fields. The release rules permit the validation report to the release agent; raw source is not a permitted output.

    3. Authorize

    The release owner prepares and encrypts the candidate and any private checks in its environment, retains the expected input digests and configures key access for the accepted confidential runtime. Requests carry encrypted-input references, never private contents in agent conversations or tool arguments. See Inputs and permissions.

    Each required owner approves in the Console with a passkey: per operation, or under a standing permission with a use count and expiry that covers routine verification runs within the accepted scope. Standard checks current authority on every operation; changed scope or expired permission needs fresh authority. No interface approves on an owner’s behalf: an operation without the required approvals or a current standing permission waits or is refused.

    The release agent is the permitted recipient, even though the coding agent requests the checks. Its identity must be bound and authorized; declaring a recipient role in a profile grants nothing.

    4. Run

    Request the operation with the accepted profile and your inputs. Inputs are encrypted on your host and contributed only after the runtime passes appraisal.

    bash
    standard run release-checks --input candidate=./service-api-2.14.0.tar.gz

    From an application or a CI/CD job, the SDK submits the same operation:

    ts
    const operation = await standard.run('release-checks', {
      inputs: { candidate: './service-api-2.14.0.tar.gz' },
    });

    From an agent, connect through MCP, ask the agent to discover the operations available to its identity and request the release-verification operation using the identifiers and fields its tool schema supplies. The example manifest above is sample data, not a tool request. Whichever entry point sends the request, Standard checks the same authority and runs the same accepted workload.

    5. Receive and verify the result

    The permitted recipient receives the result. The CLI and the SDK verify Standard Proof before they write or return anything:

    bash
    standard receive 7f3c… --out ./out
    ts
    const { report, proof } = await operation.receive();

    Example report for the candidate above:

    json
    {
      "artifact": "service-api-2.14.0.tar.gz",
      "checks": [
        { "id": "unit-tests", "outcome": "pass" },
        { "id": "secret-scan", "outcome": "pass" },
        { "id": "license-policy", "outcome": "fail" }
      ]
    }

    The actual result format follows the accepted output contract. The release agent also receives Standard Proof. Its trusted integration verifies the runtime, workload revision, candidate and result bindings, required authority and recipient against independently accepted references. Configure those references and the verification policy before accepting results. Verification can run automatically in the recipient’s environment.

    Valid evidence can still report failed checks. The release agent evaluates the report and applies its own deployment policy to the exact candidate. Accepted evidence does not prove the code has no defects or authorize deployment. See Verification checks.

    Handle refusals and failures

    OutcomeApplication behavior
    Missing or expired authorityKeep the operation blocked; obtain the required authority or narrow the request
    Unsupported input or requested limits exceededCorrect the format or resource request; do not treat the refusal as a result
    A limit is reached during executionInspect the reported failure and stage; do not accept a partial run as success
    Release refusedNo protected result reaches that recipient; successful execution does not override the refusal
    Required verification failsReject the result and stop the dependent action
    Timeout or uncertain statusReconcile the existing operation before resubmitting; follow its bounded retry and idempotency rules

    Execution, delivery and cleanup are separate statuses. Retain the operation identifier and safely redacted failure information for diagnosis. See Results and lifecycle.

    Add owners when the function needs them

    The same process can involve a vendor’s program or a partner’s records. Each required owner authorizes its own contribution and result release. An invitation, account connection or payment grants no authority over another owner’s assets. See Join a Space.