Trusted collaboration for AI agentsEarly access

Let agents work together. Keep every organization in control.

Standard is building infrastructure for agents, people, and services to work across trust and control boundaries—without sharing full context, handing over credentials, or giving up control.

$ standard space run sp_01J8Q4K7 --followsimulated
  1. spacesp_01J8Q4K7policy=production-review ttl=30mCREATED
  2. contextsecurityco/reviewerfull-repositoryDENIED
  3. toolacme/releasedeploy.productionBLOCKED
  4. consensusresolverproduction-review: 4/4 required conditions metSATISFIED
  5. releaseresultto=acme hash=sha256:9c1d…RELEASED
  6. retainsp_01J8Q4K7result, policy hash, approvals, evidenceRETAINED
Simulated production-review Space — policy decisions in real time.Full example

The new way work moves

AI work now crosses organizations. Control rarely follows.

One workflow can involve your agent, a partner’s model, private data, external tools, and a human approver. The collaboration is still held together by copied context, shared credentials, and approvals that sit outside the execution path.

Trust

Trust is enforced, not assumed.

Every Standard Space provides isolated execution, scoped access, short-lived authority, policy-controlled release, and verifiable evidence—then destroys transient state when the work is complete.

How Standard creates trusted Spaces

The Standard Space

One trusted place for the part that crosses the boundary.

A Standard Space is a temporary execution domain for the part of a workflow that cannot safely happen in either party’s environment. Agents and services can stay where they already run. Each principal contributes only the code, data, logic, capabilities, or evidence the collaboration needs.

  1. Contribute only what is needed

    Each principal decides what assets enter the Space and under what conditions.

  2. Reveal selectively

    Participants receive only the context and derived information policy permits.

  3. Grant authority just in time

    Capabilities become available only when their conditions are satisfied and expire automatically.

  4. Release only what was approved

    Only policy-approved outputs leave. Transient assets, credentials, and working state can be destroyed afterward.

See it in action

From change to release—without handing over the keys.

Any principal can contribute protected code, data, models, logic, capabilities, or evidence. Standard governs how those contributions can interact and what may leave.

This simulation shows several principals contributing protected assets and authority into one temporary Space. Their agents and services may continue running where they already live; only the trust-sensitive part of the workflow enters Standard.

What enters the Space

  • AcmeSelected source code, proposed change, scoped CI capability.
  • SecurityCoProprietary review logic, threat intelligence, review policy.
  • Validation providerTest logic, test environment capability, validation evidence.
  • Acme release authorityApproval authority bound to the exact artifact when policy requires it.
$ standard space run sp_01J8Q4K7 --followsimulated
  1. spacesp_01J8Q4K7policy=production-review ttl=30mCREATED
  2. contributionacmesource:src/auth/**ACCEPTED
  3. contributionacmeproposed-change:feature/auth-refactorACCEPTED
  4. contributionacmeci:scoped-writeACCEPTED
  5. contributionsecuritycoreview-logic:v3ACCEPTED
  6. contributiontestcotest-logic:v2 + test-env:capabilityACCEPTED
  7. principalacme/release-authorityapproval bound to artifact when policy requiresADMITTED
  8. contextsecurityco/reviewerdiff + auth-pathRELEASED
  9. contextsecurityco/reviewerfull-repositoryDENIED
  10. capabilityacme/cibranch.write scope=feature/* ttl=15mISSUED
  11. toolsecurityco/reviewervuln.scan via cap_83af (handle, not secret)ALLOWED
  12. toolacme/releasedeploy.productionBLOCKED
  13. evidencetestco/validationtest.result=PASSRECORDED
  14. evidencesecurityco/reviewerblock=false confidence=0.91RECORDED
  15. approvalacme/release-authorityartifact=sha256:4f2a… decision=APPROVERECORDED
  16. consensusresolverproduction-review: 4/4 required conditions metSATISFIED
  17. capabilityacme/releasedeploy.production artifact=sha256:4f2a… ttl=5mISSUED
  18. releaseresultto=acme hash=sha256:9c1d…RELEASED
  19. destroysp_01J8Q4K7raw inputs, working context, tokens, space keysDESTROYED
  20. retainsp_01J8Q4K7result, policy hash, approvals, evidenceRETAINED
  21. spacesp_01J8Q4K7receipt=rcpt_01J8Q4M2DESTROYED
A simulated event stream showing the policy decisions made during one production-review Space.
  1. Context stays scopedSecurity receives the change and relevant auth paths. A request for the full repository is denied.
  2. Authority is conditionalProduction deploy stays blocked until policy passes. A short-lived deploy capability is issued only for the approved artifact.
  3. Release follows evidenceReview, security, and validation results must satisfy the release policy.
  4. The Space has an endEphemeral context, tokens, and keys are destroyed. The approved result and receipt remain.

Your stack stays

Standard adds the boundary around the work.

Your agents stay where they are. Standard appears only when work crosses a trust boundary.

Keep the tools you already use. Standard is designed to step in only where participants need to work together under one agreement.

  • Agent frameworks

    Keep planning, routing, memory, and ordinary agent-to-agent work in your existing framework.

  • Identity and authorization

    Keep your identity provider and delegated credentials. Standard is designed to use them to verify participants and scope authority.

  • Agent security

    Keep threat detection and runtime guardrails. Standard is intended to define what collaboration is permitted in the first place.

  • Protected compute

    Use the execution substrate your assurance level requires. Standard is designed to apply the same portable collaboration model above it.

What Standard adds

One ephemeral agreement across everyone involved: separate access, conditional authority, an approved release, and a clean end.

Product preview

See the interfaces we are building.

These early interface previews show how Spaces are intended to fit an existing workflow. The planned portal makes participation, live activity, decisions, approved evidence, what left the Space, and teardown reviewable.

CLI preview
standard space create --policy production-review
standard space run sp_01J8Q4K7 --task change.json
standard space inspect sp_01J8Q4K7
standard receipt verify rcpt_01J8Q4M2
Python SDK preview
space = standard.Space(
    policy="production-review",
)

result = await space.run(task)
result.receipt.verify()
API preview
POST /v1/spaces
GET  /v1/spaces/{id}
POST /v1/spaces/{id}/context-requests
POST /v1/spaces/{id}/actions
POST /v1/spaces/{id}/destroy
MCP preview
space.create
space.run
space.inspect
context.request
action.submit
receipt.verify

The portal shows

  • Participants — who joined, what each one contributed, and what access each one received
  • Activity — what is happening in the Space right now
  • Decisions — which requests were allowed, denied, transformed, or escalated
  • Evidence — the claims, test results, approvals, and artifact versions behind what may leave the Space
  • Lifecycle — what left the Space, what was retained, destroyed, or is still pending deletion

Why it matters

The critical step is the handoff across a trust boundary.

Frameworks, identity, and guardrails stay in place. Standard is designed to govern the ephemeral agreement where private inputs meet, authority is earned, and only an approved result leaves.

Target contract

A control model you can inspect.

Early access is validating a contract that ties every important decision to the rules, the participants, and the exact version of the work.

What the target runtime must control

  • The target contract requires access, capability, and release requests to be evaluated against the accepted Space policy.
  • It requires ephemeral authority to be scoped to the Space, participant, purpose, and lifetime.
  • It requires the final receipt to bind the released result to the recorded policy, evidence, approvals, and artifact versions.

Standard does not promise

  • That every participant is honest or every approved output is safe.
  • That a passing test proves universal correctness. It proves the named test passed.
  • That information can be recalled after an authorized recipient receives it.

Early access

Bring one workflow that crosses a trust boundary. Define what must be true.

Early access is for design partners with a real cross-organization or cross-control-boundary workflow. We will use that workflow to test the Space model, expose missing controls, and agree on the evidence required before broader use.

  1. Map the boundary

    Identify the participants, private assets, trust assumptions, and exact result that needs to cross the boundary.

  2. Pressure-test the controls

    Walk through admission, scoped context, conditional authority, approval, release, and teardown against the real workflow.

  3. Set the evidence bar

    Define what your security, platform, and business owners must be able to inspect and verify before a pilot.

Early access is scoped around one workflow, with deployment assumptions and success criteria agreed up front. Ready to start? Apply for early access.

Commercial direction

Pricing follows Space capacity, not seat count.

Three envelopes—Developer, Team, and Enterprise—scale with concurrent Spaces, compute inside each Space, and how long evidence is retained. Public list prices are not fixed yet; early access and design-partner terms are scoped around one workflow.

Concurrent Spaces

Capacity for the number of trusted collaborations running at the same time.

Compute size

Compute capacity matched to the work running inside each Space.

Evidence retention

Retention windows for receipts and the evidence approved to remain.

See plans

Shape Standard around a real trust boundary in your work.

If agents, people, or services with different authority or access need to work together, bring us one workflow that crosses a trust boundary.