Reference for Standard’s Control transaction, CLI, MCP transport, application bindings, participant custody, and execution evidence.
Start with the interface you use. MCP, the SDK and the CLI share authority and verification requirements, but their custody, setup and execution capabilities differ. Connecting through any of them identifies the caller; it grants no access to another participant’s assets, and each operation still needs every required owner’s authority.
An agent in an MCP-compatible client originates configured requests. Installed MCP can return result bytes to an authorized recipient after verification; hosted MCP returns delivery metadata and, where permitted, the result location. The remote endpoint is https://standardruntime.com/api/mcp (Streamable HTTP), and connecting requires OAuth authorization of your account. MCP does not give Standard custody of the agent’s files. See Connect for setup and current execution limits.
Current hosted continuation limit
After admission approval, if Control has not reported progress, hosted status returns hosted_continuation_unavailable. The hosted continuation transport is not available on that path; repeated polling does not start it. Connection, proposal creation and approval do not establish successful execution. Agree the supported route during assisted setup.
Application integration
The Node.js bindings run the installed CLI, which verifies Standard Proof before returning result bytes to an authorized recipient. Hosted and browser bindings return operation and delivery metadata; the configured recipient verifies Standard Proof on its delivery path.
Receiving results in the SDK
For an operation identifier supplied by your configured workflow, the installed SDK calls the CLI and distinguishes verified bytes from a hosted delivery record:
ts
const received = await standard.operation(operationId).receive();
if ('value' in received) {
// Uint8Array: the permitted bytes verified by the installed CLI.
const resultBytes = received.value;
const verificationSummary = received.proof;
} else {
// Metadata only: retrieve the sealed object through the recipient path.
const sealedLocation = received.location;
}
standard is an installed Standard client and operationId is the actual operation UUID. receive() has no report property. Its installed proof field contains operation, activation, attempt and recipient identifiers plus stage: 'received'; it is a local verification summary, not the complete signed evidence document. Validate the returned bytes against the workload’s accepted output schema before using them. For Conversation analytics, accept either the defined count result or a redacted failure report, and enforce publication policy separately.
Hosted metadata does not mean that result bytes have been retrieved or verified. The authorized recipient obtains the sealed object and verifies it through its configured delivery path.
CLI guide
The CLI sets up encrypted storage, key access and permissions, and submits tasks from terminals and scripts. Use it for participant-side preparation and review workflows.
Protocol reference
Every entry point carries the same transaction underneath: an operation request checked against the accepted profile, owners’ permissions, and account limits; protected execution; and a result with evidence the receiving client verifies.
Agent-facing requests carry references rather than raw credentials. Local-file routes let the participant host prepare encrypted contributions. Connected-source routes identify a connection and selection; attested confidential ingress retrieves and validates the material under scoped permission.
Always use the tools, methods and schemas your authenticated account actually exposes. Do not invent task names, fields or capabilities.
Delivery and recipient verification
The Conversation analytics example uses conversation-categories with the approved batch-042 source reference. Hosted responses contain operation and delivery metadata, not verified plaintext category counts. The Analytics integration retrieves the permitted result through its configured delivery path and verifies Standard Proof against trusted function, input, authority, runtime and result references. Only then are counts available to the Analytics agent. Publication remains a separate reporting-policy decision.
An accepted failure report can say that the function rejected duplicate conversation IDs and produced no counts. That workload check is implemented by the example function; it is not a built-in guarantee for arbitrary functions.
Operation requests
An operation request describes one task under an accepted operation profile. It contains:
Part
Contents
Profile and Space revision
The exact accepted profile and Space governance revision for this operation.
Code or model
A reference to the approved code or model and its exact digest.
Inputs
Local encrypted-input references or approved connected-source selections, with the required version, digest and size bindings.
Requested result
The result type and recipient, which must fall within the owners' release rules.
Parameters
Task-specific options, within the limits the task allows.
Resource request
The compute, memory and duration the task needs, within your account's limits.
Idempotency key
The operation’s supported key for safe resubmission and reconciliation. Follow its documented scope and retention behavior.
Standard checks the request against the accepted profile, owners' permissions, supported formats, and account limits before admission. An invalid request is rejected with a reason.
Runtime and contributions
The executable workload is an approved Wasm module. Code, models, and data used by that workload must match its supported formats and the runtime's limits. An arbitrary container, model server, or complete agent loop is not a supported workload merely because it can run elsewhere.
Formats and limits
Every task runs within declared limits:
Approved Wasm workloads must declare a supported executable interface. Their code, model, and data inputs must fit the accepted profile.
Tasks run in bounded execution windows, not as continuously hosted services. Each task declares its duration, memory, fuel, and input and output sizes, and the runtime enforces them.
Functions are called under three visible limits. The memory tier is the memory each call may use. Concurrency is 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. The per-call time limit is the longest one call may run, and the runtime enforces it during the call. The required owners approve these limits with the function’s terms; your organization’s plan sets their ceilings. Concurrent calls on one host share its confidential runtime and are not separate hardware-isolation domains.
Organization limits such as concurrency, total runtime and resource ceilings are agreed for your organization. Each entry point reports which limit applied when a request exceeds one.
A request that exceeds a limit is rejected before it runs. Runtime resource limits also apply during execution. A function keeps no private working state from one call to the next, and reusing a Space does not provide resumable private working state or a continuously running task.
Errors
Errors name the lifecycle stage that failed and a stable reason code, so your integration can decide whether to fix, escalate or retry. The categories match Results and lifecycle: missing permission, key access refused, input mismatch, unsupported or over limit, and verification failed. Follow the operation’s status and retry guidance for transient capacity problems. Reconcile uncertain external effects before resubmission.
For agents
The plain-text guide at /llms.txt gives agents the same product description and instructions as these pages.
Author the function
Implement customer-defined calculations and checks through the supported workload interface, then bind the accepted code and rule inputs in the operation profile. Write a protected function covers the named-buffer interface, failure reports, testing and revision acceptance.
Input routes and customer vaults
See Sources and customer vaults for connection selection, custody, approval timing and the protected flow. The examples below show the supported request contracts.
Customers keep persistent control of keys and API secrets in their own vaults or key stores. Non-exportable master keys stay there; transient data keys or API secrets can be used in the appropriate confidential components. Raw protected material stays out of agents and Standard’s coordination services.
Connection verification and approval-time snapshots can happen before final operation approval, under separate scoped permissions. Before retrieval, ingress checks the selected connection and resource against the owner-approved grant. Retrieved bytes must then match the required digest and size before contribution to the worker.
Local encrypted-file route
On an enrolled participant host, the CLI reads and prepares the local file. This is request syntax for a previously published conversation-categories profile; the guide does not supply a complete Wasm project or install that profile:
sh
standard run conversation-categories --input conversations=./batch-042.json
The file must be available to that participant host.
Connected-source route
For a configured hosted principal, the current CLI accepts --source SLOT=CONNECTION/OBJECT[@GENERATION]. Example values below name an object-storage connection, conversation batch and pinned version. The UUID, object and generation must be replaced with the approved selection for your account; batch-042 alone is not a source selector. Connection families and selectors must be supported by the chosen route. Installed-owner custody is refused on this route; the current hosted continuation limit above applies even when origination succeeds.
sh
standard run conversation-categories --source conversations=11111111-1111-4111-8111-111111111111/conversations/batch-042.json@1740000000000000
The installed Node.js SDK exposes the same CLI route with sources instead of inputs:
js
import { Standard } from '@standardruntime/sdk';
const standard = new Standard();
const operation = await standard.run('conversation-categories', {
sources: {
conversations: '11111111-1111-4111-8111-111111111111/conversations/batch-042.json@1740000000000000',
},
});
const state = await operation.status();
For that hosted operation, the requester's host receives nothing. The authorized recipient receives the result on its own installed host and verifies Standard Proof there.
Installed standard-mcp exposes standard_run with the same sources map:
Hosted MCP is a different transport: it exposes standard_request_protected_task and standard_hosted_operation_status with their discovered schemas. Use the discovered schema for each hosted tool. A recipient receives on its own installed host.
Query snapshots and customer-vault secret references use their connection-specific selectors. See the threat model and AI risk mapping for provider differences and the distinction between internal source checks and recipient-verifiable source claims.