What it actually is

SG/Compute launches an isolated environment, runs the declared work, and destroys it. That happens at two different scales with two different lifetimes, and almost every first reading of this platform collapses them into one. Separating them is the most useful thing this page can do.

Layer 1 — the browser, per request

From the source, verbatim:

“Layer-3 multi-step execution. Stateless by design: every call launches a fresh sync_playwright + Chromium, runs the declared step list, and tears both down in try/finally before returning.”

And, separately: “Each call to launch() starts a fresh sync_playwright() Node subprocess AND a fresh Browser” — so there is zero cross-request state, not merely a cleared one.

What makes that an architectural rule rather than a convention is that it has a mechanism behind it. Page__Factory is the single sanctioned path to a Page, and a CI guard fails the build if any raw browser.new_context( appears anywhere else. That is rarer than it should be: most codebases state this rule in a style guide and then discover the exceptions in production.

The request lifecycle

parse steps
  -> reject duplicate ids
  -> validate
  -> launch fresh Chromium
  -> new context + page
  -> apply credentials
  -> iterate steps against a deadline   # remaining steps marked SKIPPED on halt
  -> derive COMPLETED / FAILED / PARTIAL
  -> try/finally ALWAYS tears down
  -> return, with a full timings block

Note the deadline behaviour: a halt does not discard the run. Steps that did not execute are returned marked SKIPPED, and the overall status distinguishes a partial run from a failed one. That distinction is what makes the surface usable by an agent that has to decide whether to retry.

Sessions — the exception to statelessness, and why it exists

Statelessness is the default, not a religion. A held session gets one dedicated OS thread, owning the Playwright runtime, browser and page for the session's whole life. The rationale is a real bug, documented in the source:

“Playwright's sync API is greenlet-based… Calling page.goto / page.locator(...) from a DIFFERENT thread leads to undefined behaviour (deadlocks, silent hangs, or ‘navigate failed’ with no error_message — the exact symptom session_act was hitting in CI).”

So thread affinity is not an implementation detail that leaked into the design; it is the design, and it was paid for.

Both are capped at capabilities.max_session_lifetime_ms. Expiry is swept lazily — at the start of every registry operation and from service setup — so any request to any endpoint sweeps idle sessions and there is no background thread. Teardown runs on the worker thread, for the same Playwright affinity reason. The idle cost, from the source: “the worker blocks on queue.get() — 0% CPU, ~few KB of RAM.”

The watchdog — the best engineering story in the repository

Request__Watchdog runs a daemon thread. If any in-flight request exceeds max_request_ms, it calls:

os._exit(2)

Not a graceful shutdown. Not an exception. The process dies.

The interesting part is the reasoning, which is in the source rather than in a design document. time.sleep releases the GIL, so the watchdog keeps ticking even through a main-thread deadlock — which is precisely the state you need to recover from. And os._exit bypasses cleanup, finally blocks and GIL contention, which is exactly what a graceful shutdown cannot do from inside a deadlock: it would queue behind the thing that is stuck. The Lambda Web Adapter sees the process die, and AWS hands the next invocation a fresh container.

It was written against a real production deadlock. A platform that publishes the failure and the mechanism reads very differently from one that publishes a feature list.

Layer 2 — the EC2 node

sg_compute/platforms/Platform.py is the abstraction — create_node, list_nodes, get_node, delete_node — carrying name: str = '' # 'ec2' | 'k8s' | 'gcp' | 'local'. Only EC2__Platform exists. Whether that comment describes an abstraction or an aspiration is Q3, published unresolved.

Teardown is the part worth publishing

systemd-run --on-active={seconds}s /sbin/shutdown -h now

paired with InstanceInitiatedShutdownBehavior=terminate. Halt means terminate, not stop — the instance does not linger in a stopped state accruing EBS charges and waiting for someone to notice it.

• Default max_hours = 1 across every spec. vault_app supports fractional values (0.1 = six minutes); max_hours=0 disables the timer entirely.
• Explicit delete, at any time.
• Idle reconciliation — SG_Edge__Fleet__Reconciler with IDLE_TEARDOWN_THRESHOLD = 3: three consecutive zero-vault idle checks at a five-minute cadence, so roughly fifteen minutes.

And a detail that shows the code was written by someone who had been bitten: on spot instances the shutdown flag is deliberately skipped, with the reasoning inline — “spot non-hibernation instances always terminate on OS shutdown; skip the flag (it's silently ignored).”

How artefacts come back — correct the likely assumption

Enum__Artefact__Sink declares four sinks: VAULT, INLINE, LOCAL_FILE, S3. The default is INLINE.

The gap matters more than it looks, because two specs exist whose declared capability is literally vault-writes. The capability is real at the spec layer and missing at the platform layer — Q4.

Isolation boundaries

Each row is a boundary with a named mechanism, not a policy statement.

The boundaries in full, the one deliberate exception to deny-by-default, and the trade-off the code itself comments on →