# Standard > Standard is a managed confidential execution service: approved Wasm workloads start just in time inside an attested trusted execution environment, scoped authority and release rules stay outside the caller, and each permitted result includes Standard Proof. > Your agents keep their planning and orchestration. Customers put required calculations, validations and decision rules into approved functions. Agents request those functions; Standard executes the accepted workload on protected inputs under owner permissions and release rules. Standard does not host complete agents or accept arbitrary workloads. Membership in a Space does not grant access to another participant’s private inputs or permission to run every operation; sponsoring a Space does not grant authority over another owner’s assets. ## Availability Space access is by request: request access for your organization and describe the work you want to run. Connecting an agent does not grant execution access or authority over another owner’s resources. Next step: https://standardruntime.com/contact?intent=space-access ## Documentation These pages are the source for this guide. Read them for detail. - [Conversation analytics](https://standardruntime.com/docs/conversation-analytics): The conversation-categories example: protected input, duplicate-ID validation, permitted counts, recipient verification and publication policy. - [Write a protected function](https://standardruntime.com/docs/write-a-protected-function): Turn required calculations and business checks into an accepted Wasm function, test its behavior, and verify its permitted result. - [Sources and customer vaults](https://standardruntime.com/docs/sources-and-vaults): Connect supported data sources, keep control of keys and API secrets, and authorize protected retrieval and processing. - [Overview](https://standardruntime.com/docs/overview): Start with one approved function: what Standard manages, what owners control, and how the receiving integration verifies the permitted result. - [How Standard works](https://standardruntime.com/docs/how-it-works): How customer-defined functions, operation profiles and owner permissions work together, from protected inputs and execution to results with Standard Proof. - [Run your first task](https://standardruntime.com/docs/first-task): Follow Conversation analytics from an approved function and conversation batch to verified counts and a separately authorized report update. - [Connect](https://standardruntime.com/docs/first-task/connect): Sign in from the CLI, authorize the SDK from your code, or connect an agent through MCP; every entry point reaches the same account and operations. - [Join a Space](https://standardruntime.com/docs/join-a-space): Review the proposed work, authorize your contribution, and choose what may be released, without joining another organization’s account. - [Examples](https://standardruntime.com/docs/examples): Explore Conversation analytics and separate examples for release verification, diagnostics, supplier assessment, model scoring and joint analytics. - [Software release verification](https://standardruntime.com/docs/software-release-verification): A separate example: validate a candidate artifact with approved checks, verify the findings and enforce deployment policy. - [Operation profiles](https://standardruntime.com/docs/execution-packages): Define the program, participant roles, inputs, permitted outputs, and execution limits. - [Inputs and permissions](https://standardruntime.com/docs/inputs-and-permissions): How encrypted inputs and key access work, how each required owner authorizes independently, and how each operation is approved when it is requested. - [Accounts, Spaces and billing](https://standardruntime.com/docs/inputs-and-permissions/accounts-spaces-billing): How accounts, Spaces and invitations relate to permissions, and why connecting or paying never grants rights over another owner's inputs. - [Results and lifecycle](https://standardruntime.com/docs/results-and-lifecycle): Automatic verification and result delivery, approval requests, failures, retries and cleanup status. - [Verification checks](https://standardruntime.com/docs/results-and-lifecycle/verification-checks): The evidence reference: each check the receiving client runs automatically, the references it uses and where it runs, for integrators and auditors. - [Follow-on tasks](https://standardruntime.com/docs/results-and-lifecycle/follow-on-tasks): Use one task's verified result as the input to another, with evidence linking the two. - [Cleanup](https://standardruntime.com/docs/results-and-lifecycle/cleanup): What Standard removes after a task, what it keeps, and when cleanup counts as complete. - [Integration reference](https://standardruntime.com/docs/integration-reference): Reference for Standard’s Control transaction, CLI, MCP transport, application bindings, participant custody, and execution evidence. - [Threat model and AI risk mapping](https://standardruntime.com/docs/threat-model): How Standard’s execution controls and approved customer functions address specific threat scenarios using MIT’s risk and mitigation taxonomies. - [Security model](https://standardruntime.com/docs/security-model): How scoped authority, confidential ingress, protected execution and Standard Proof govern sensitive work. ## Current execution availability Complete assisted setup before following operation examples. The installed Node.js SDK requires the CLI; local MCP requires the enrolled owner host. Obtain the client bundle and, for local authoring, its pinned preparation image through the agreed setup path. See https://standardruntime.com/docs/first-task/connect#before-you-connect. Hosted origination and approval do not establish execution. After admission approval, if Control has reported no progress, hosted status returns hosted_continuation_unavailable: its continuation transport is not available on that path. Further polling does not start it. Connected-source CLI requests currently require hosted custody. Confirm the supported route during setup. ## Connect, execute, verify 1. Connect an authorized identity through the CLI, the SDK, or MCP. OAuth authorizes a connection, not a payment or unrestricted resource access. 2. Discover the actual tasks and schemas available to the authenticated account. Follow them; do not invent tool names, task fields, formats, or capabilities. 3. Implement and accept the function’s calculations, checks and failure behavior. Define the operation profile, resources, result recipients, and accepted verification references. Each required owner authorizes its own contribution and release; one owner’s approval cannot replace another’s. Each operation must satisfy its required admission and release approvals when it is requested, unless that owner opted in to a standing permission for that exact task (same inputs, recipients and release rule; no connected sources; at most 100 runs over at most 30 days; revocable). An agent cannot change what a standing permission covers. 4. Use local encrypted contributions or approved connected-source selections. Bind the expected input and rule configuration to the accepted function. Customers retain control of keys and API secrets in their vaults or key stores; requests carry references. Confidential ingress validates connected-source material before contribution. 5. Follow the operation’s status and idempotency contract. A submitted request, a lost response, or a running process does not establish completion. 6. Verify Standard Proof in the recipient’s trusted integration against accepted references. Missing or failed required checks block acceptance. Evaluate the result and authority for the next action separately. ## Write a protected function Use the supported named-buffer Wasm interface for the agreed execution path. Define input and rule formats, implement required calculations and validation, test success and refusal behavior, then accept the code and configuration revisions outside the requesting agent’s authority. The introductory path is https://standardruntime.com/docs/conversation-analytics followed by https://standardruntime.com/docs/first-task. The separate technical guide at https://standardruntime.com/docs/write-a-protected-function uses sales-total to demonstrate the Wasm interface. Software release verification is a separate example at https://standardruntime.com/docs/software-release-verification. ## Example: Conversation analytics The Analytics agent requests conversation-categories for approved batch-042. The classifier and any model it uses execute inside the protected runtime. Its reference function checks for duplicate conversation IDs before counting categories; a duplicate produces a redacted failure report and no category counts. This is customer-defined workload logic, not an automatic Standard guarantee. The example result is Coding 420, Writing 310, Research 190 and Other 80, totaling 1,000. Hosted responses carry operation and delivery metadata. The Analytics integration retrieves the permitted result and verifies Standard Proof against trusted references before making counts available to the Analytics agent. The reporting workflow separately enforces publication policy. Execution evidence does not certify classification accuracy or the truth of source conversations. See https://standardruntime.com/docs/conversation-analytics for the reference logic, permitted outputs and four outcomes. ## Separate example: code verification to release A coding agent submits a candidate artifact. The release owner controls an approved Wasm verification workload, test suite, and acceptance policy. The producing agent cannot replace those checks under its own authority. Standard Proof binds the recorded verifier execution and outcomes to the exact candidate. The release integration verifies the evidence, evaluates the findings against its release policy, and enforces authority for release. Valid proof can report failed tests or security findings. Only the exact tested artifact may proceed when the required conditions pass. A new artifact needs its own evidence. ## Multi-owner expansion: vendor diagnostics A customer’s maintenance agent asks a vendor to diagnose an equipment issue. The customer contributes an encrypted telemetry window; the vendor contributes its proprietary diagnostic program. Each owner authorizes its own contribution and the release of results. An assurance team receives only the permitted findings and verifies Standard Proof before acting. Neither owner receives the other’s raw input. Private inputs never travel through MCP. Do not put raw private files, private keys or secret material into MCP arguments or ordinary model context. Previously disclosed information cannot be made private retroactively. ## Product and connection - [Homepage](https://standardruntime.com/): managed confidential execution for approved functions. - [Examples](https://standardruntime.com/docs/examples): five example operation profiles with their definition and configuration files. - [How Standard works](https://standardruntime.com/docs/how-it-works): approved Wasm workloads, scoped authority, confidential execution, controlled release, and Standard Proof. - [Security](https://standardruntime.com/docs/how-it-works#trust): who authorizes, where plaintext is, what can leave, and what is not covered. - [What you can verify](https://standardruntime.com/docs/how-it-works#verification): what execution evidence establishes, and what it does not. - [Connection guide](https://standardruntime.com/connect): sign in from the CLI, authorize the SDK, or connect an agent through MCP. - Remote MCP endpoint: https://standardruntime.com/api/mcp (Streamable HTTP; authenticated account access required). - [FAQ](https://standardruntime.com/faq): when to use Standard, how it protects work, and how to get started. - [About](https://standardruntime.com/about): the purpose, founder, and principles behind Standard. - [Pricing](https://standardruntime.com/pricing): pricing is quoted per organization. The sponsoring organization pays for execution; invited contributors don’t need a separate paid plan to participate, but still sign in and authorize how their own inputs are used. ## Broader ambition Verifiable autonomy is the broader ambition described on About, not a claim that Standard verifies every agent decision. The product’s scope is managed confidential execution of approved, sensitive agent functions. Evidence of an execution does not establish that an agent’s overall plan or subsequent actions are correct. ## Runtime, Space, task Standard manages an attested runtime for supported operations, including workload activation, execution limits, result release, evidence, and cleanup. A Space binds participants, an agreed operation profile, each required owner’s authority, release rules, and verification expectations for one or more tasks. It can serve a single organization’s agents or several independent owners. Joining it does not grant unrestricted rights over other participants’ inputs. ## Application and runtime responsibilities Existing agents retain their planning and orchestration. Customers define the selected function’s business logic, required checks and failure behavior. Standard executes that accepted workload with owner permissions, protected input handling, controlled release and Standard Proof. For confidential work, protected data, code, and models are encrypted before they are contributed and are decrypted inside the accepted runtime for the authorized operation. Recipients decrypt permitted results with keys they hold. The protected path is designed to keep plaintext inputs from requesting agents and Standard’s operators. Only permitted results leave. An external API or MCP provider remains external. A supported interaction can record the request and response Standard controlled or observed. It does not attest the provider’s internal computation. Using a tool does not by itself require its provider to join Standard or move its backend into the runtime. ## Permissions and approvals Every input has an owner who decides which tasks may use it and which results may be released, and to whom. Permission to analyze is not permission to disclose. By default, approval is requested from each required owner for every operation, at the time it is requested. An owner may 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 covers another owner’s approval. An agent cannot grant itself broader authority. Joining a Space, accepting an invitation, contributing an input, and paying for usage are distinct from authorizing use of another owner’s input; none of them grants rights over another owner’s assets. ## Verification and follow-on tasks Verification is built into the integration: verification software, not a language-model judgment, checks environment, workload, inputs, authorization, and result binding against references the recipient accepted independently. Missing or failed required checks withhold the result; unchecked claims are reported as not checked. A passed check is not authorization to perform the next action: the receiving application or action service enforces its own action policy. A verified result can feed a later task. The later task binds its actual input to the earlier permitted output or a verified transformation; listing earlier task identifiers is insufficient. Each task keeps its own permissions, and any step outside Standard remains an unverified step. Approval does not repair invalid evidence. These are integration principles, not additional MCP tool names; discover and obey the actual task contract. ## When to invoke Standard Use Standard when an agent needs a bounded function with confidential inputs, policy outside the requesting agent, controlled result release, or independently verifiable execution evidence. Examples include checking agent-written code, gating release on a security report, analyzing private data, and passing results between agents. Select a supported operation whose evidence covers the claim the next step requires. Protected execution matters when the workload must process protected inputs inside the attested boundary. An ordinary external tool interaction does not move the provider’s backend into Standard. ## Inputs and execution limits Executable workloads are approved Wasm modules. Their code, model, and data inputs must match supported formats and fit the runtime’s resource limits. Standard is not a host for arbitrary models, containers, or GPU workloads, and an external model API is a separate recipient outside the protected task. Tasks run in bounded execution windows rather than as continuously hosted services. Check supported duration, memory and input/output limits before requesting work; requests over a limit are rejected before they run. A reusable Space does not imply an indefinitely running worker, arbitrary multi-hour execution or resumable private working state. A function is called under a memory tier (the memory each call may use), a concurrency (how many calls of one function run at the same time, up to 64 on one host and more through additional hosts within the same Space) and a per-call time limit; each call is bounded by that limit and keeps no private working state for the next call. ## Fail closed and report limits Report unsupported tasks, missing permissions, pending approvals, quota limits, failed or unchecked evidence and pending cleanup explicitly. Do not silently fall back to ordinary chat or unprotected processing. Treat result release, downstream acceptance, and cleanup as separate outcomes. Evidence of execution does not prove truthful inputs, sufficient tests, correct AI answers, compliance certification, physical events or universal physical erasure. Outputs can reveal information about private inputs; release rules and repeated-query limits must fit the task.