Machines and links

A machine is a live or stopped computer an agent works on: a copy of an environment's image, or a conversation's own sandbox. A pilot drives it for one run or one turn: our agent or a harness (Claude Code, Codex, Cursor). A link is one port of a machine, published at https://<slug>.standards.run, that the members allowed to read the work can open in their browser, even after the machine has gone to sleep.

So a routine that says "the feature is on PR #6747" can hand you the running app: you open it, try the gesture, and approve or not.

The machinesCopy Anchor Link

Every machine has one row in the workspace, whatever started it, and each is known by its key:

Routine runs on a default environment, or on none, run on a machine that ends with the run and is not listed here.

What keeps a machine. A machine is destroyed when its key has ended and none of its links is valid and no open decision points at it. Until then it is stopped with its snapshot, and woken when someone opens one of its links. Its snapshot's expiry is the hard limit: past it, the machine is destroyed whatever holds it. A conversation's sandbox is destroyed the same way once its conversation is archived.

Who sees a machine. You read a machine when you can use its environment (when it has a custom one) and read what owns it: the conversation, the run, or at least one run of the branch. Supervising someone's conversations does not let you read their machines or open their links.

The leaseCopy Anchor Link

One holder at a time acts on a machine: a routine run, a conversation turn, the wake or the relaunch of a link, or its destruction. The others wait, polling every 2 seconds, and a waiter gives up after 10 minutes with 403 SCHEMA_STATE_GATE. A holder silent for 90 seconds has lapsed: the next one takes the machine over, stops whatever processes the previous holder left running, and only then acts. A write by a holder whose turn was taken answers MACHINE_LEASE_FENCED and stops. A run holds its machine as one holder: every turn of the run and its sub-agents join that hold without waiting, each keeps it alive, and it is released by the last of them to finish; a run that crashed releases it 90 seconds after its last sign of life.

The compute of a machine is metered to the person its current holder acts for, not to whoever created it. Running out of credits stops the machine once its current holder is done, never under it.

ChangesCopy Anchor Link

A change is a head branch in one environment. When a routine's Reuse the branch's machine is on and its run concerns a pull request, the run works on the branch's machine of the run's environment: pull requests in several repositories of one environment that share a head branch are one change, tested together on one machine.

These events concern a pull request: pull_request (every action), pull_request_review, pull_request_review_comment, issue_comment on a pull request, and check_run, check_suite and workflow_run attached to one. For the events that do not carry the head, Standards reads the pull request to find its head repository, its head branch and the base repository's default branch; when GitHub cannot be read, the run gets a machine of its own.

A run gets a machine of its own instead when:

• the pull request comes from a fork, or its head branch is the repository's default branch;
• its content is not readable by the whole workspace: a private run, a run of a routine with an audience, or a run under someone's own grants. A branch's machine only hosts runs every member may read;
• it was fired by the pull request closing or merging;
• a harness pilots it (Claude Code, Codex or Cursor). A harness reads its variables from its machine, set once when the machine is made, so a later run on a shared machine would not get its own.

One run at a time, in order. The runs of one branch queue in the order they arrived: a review, a fix, then a second review all run, one after the other, and none waits in a worker while it queues.

Checkout. Before a run starts, every repository of the environment is fetched and reset to the branch when it exists on that repository's remote, to its default branch otherwise. A branch deleted or force-pushed between two runs is checked out from the default branch, and the run's report says so. Later turns of the same run never reset it again, and a repository whose reset failed is reported to the run, not reset again by its next turn; only a machine whose copy was lost mid-run checks the branch out again, on its fresh copy.

Closing. When a pull request closes or merges and no open pull request of the environment's repositories has that head branch any longer, the branch's machine has ended. It is destroyed at the next sweep, unless a valid link or an open decision keeps it.

LinksCopy Anchor Link

Publishing a portCopy Anchor Link

A pilot publishes a port with publish_port (standards_publish_port on a harness), in any conversation and in the runs of custom environments. It starts the server first, listening on any interface, then calls the tool with:

The tool answers the link's url, its port and expiresAt. Publishing the same port again extends its link and replaces its command and its publisher, never a second link: on a machine several runs share, the link opens for the readers of the run that published it last. A machine exposes 15 ports at most, the bridge's included; a port over the cap answers 400 SCHEMA_VALIDATION_FAILED. A link's expiry closes its port; Relaunch opens it again.

The command runs with STANDARDS_RUN_URL (its own link) and STANDARDS_RUN_URL_<port> for every valid link of the machine, so an app can build its public URLs. Runs on a default environment or on none publish nothing, and neither does a run on an environment whose image was built before machines had one working directory, until it is rebuilt.

The link serves the machine's current state, not a picture of the moment it was published.

Opening a linkCopy Anchor Link

Opening and relaunching a link require both that you can use the machine's environment, when it has a custom one, and that you can read the run or conversation that published it. A link of a conversation without a custom environment opens for whoever reads that conversation. There are no public share links.

Open mints a single-use token bound to that link, valid for one minute. The standards.run proxy spends it, answers a redirect to the same address without it, and sets a cookie for that one address, valid 12 hours; your access is checked again each time the cookie renews, so a member who lost access is refused at the next renewal. A token is refused on a second use and for another link with LINK_TOKEN_INVALID, whatever the reason.

A woken machine runs as you. Opening a stopped machine or relaunching a command runs as the member who clicks, and its compute is metered to them. The command receives the workspace, environment and repository variables (on a machine without a custom environment, the workspace variables that reach every environment), never anyone's personal variables. A woken machine starts at the environment's size.

What you see while the link opens:

Waking is done once per machine, however many tabs ask: a second tab waits for the first wake. A machine woken by a link stops after 15 minutes without traffic (its session is extended at most once a minute, however busy the page), and when its last link expires. A stopped machine's snapshot lives 7 days: the machine's page shows that expiry, and past it the machine is destroyed whatever holds it. An expired link's tokens go at once; its address, command and publisher are kept 7 days, then purged.

The gate. The port a machine exposes to the internet is not the app's: it is a small gate on the machine that forwards to the app only when the request carries the link's secret, which only the proxy holds. A leaked provider address serves nothing, and the provider's host never reaches your browser.

In the appCopy Anchor Link

• Link card. Wherever a link shows: its address, port and command, a Live or Asleep pill, Open in a tab, Enlarge and Collapse. It loads the app inside the card only when you expand it, so scrolling past a link never wakes its machine. In a conversation it also carries the duration menu: 1 hour, 4 hours, 12 hours, or 24 hours, marked maximum.
• Conversation. The card shows in the thread where the link was published; above the composer, Live links holds one chip per valid link of the conversation's machine, with its time left.
• Decision. When a decision points at a link and you pass the access check, its card shows the link collapsed, with Test beside the answers and the link's expiry. The tab opens on your gesture; a blocked tab or a refused link says so.
• Run row. A run that worked on a branch's machine links to it, for members who read the machine.

The Machines pageCopy Anchor Link

Machines, in the sidebar, lists every machine you read, running then asleep, filtered by kind (Branches, Conversations, Routines) and environment. Each row shows its owner, pilot, size and link.

Each machine has its own page: its key and environment, its state and size, its snapshot's expiry, its links (address, port, command, time left) with Open and Relaunch, each listed only for members who may open it, and its runs and turns (routine, pilot, size, outcome, duration), each listed only for members who may read it. Only the machine's owner sees Destroy the machine: a conversation's creator for its sandbox, the environment's owner for a routine run's or a branch's machine. It asks first, naming its live links and what is using it; a machine in use is not destroyed: the dialog says what is using it, and you destroy it once that finishes.

APICopy Anchor Link

All routes sit under https://api.standards.new/v1. Each answers 404 for a machine or a link you cannot read.

A link reads id, machineId, slug, url, port, command, cwd, publishedBy, publishedFrom ({ runId } or { sessionId }), createdAt and expiresAt. A run that worked on a branch's machine carries its machineId. The /links/by-slug/… routes serve the standards.run proxy and are not called by members.

ErrorsCopy Anchor Link

See errors for the shared codes.

Next stepsCopy Anchor Link

Read environments for the recipe a machine is copied from, the pilots it accepts and the variables it receives, and agents and routines for triggers and runs.

• Book a demo