Environment Service

A common way for CI, CD, AutoFlow, DAP, and other automation to create and use execution environments.
This page contains information related to upcoming products, features, and functionality. It is important to note that the information presented is for informational purposes only. Please do not rely on this information for purchasing or planning purposes. The development, release, and timing of any products, features, or functionality may be subject to change or delay and remain at the sole discretion of GitLab Inc.
Status Authors Coach DRIs Owning Stage Created
ongoing takax ash2k josephburnett vtak ash2k vtak takax devops verify 2025-09-19

Problem

Runner compute is primarily accessed through CI jobs. CD, AutoFlow, DAP, and other automation may need to:

  • Run several operations in the same environment, keeping state between them.
  • Pause while waiting for input without keeping compute running.
  • Use shared compute without building their own environment management and scheduling.

These needs do not fit neatly into an environment that starts and ends with one job.

Environment Service

Environment Service gives CI, CD, AutoFlow, DAP, and other automation a common way to create and use execution environments. It selects suitable compute, checks which work may run there, manages environment lifetime, and reports execution status and results. Where supported, environments can stop and resume while preserving disk state.

It does not orchestrate workflows. The calling application manages dependencies and approvals, submits ready work, and decides whether to retry failed work. Environment Service durably tracks accepted requests, environments, Runs, and results, including requests waiting for compute.

The API is service-to-service. The calling application handles end-user authorization. Environment Service authenticates the caller and enforces the caller’s verified authorization context when matching compute and accessing environments, Runs, and configuration.

Functional requirements

ID Requirement
F1 Callers can create an execution environment and run multiple operations in it, retaining disk state between operations.
F2 Where supported, callers can stop an environment and resume it later with its disk state preserved.
F3 Callers can observe environment and execution status, retrieve results, and cancel an operation without terminating the environment.
F4 Where supported, callers can access an environment interactively for debugging.
F5 Work runs only on compute that meets its execution needs and access restrictions, after any required admission checks.
F6 Ready work can wait for suitable capacity. Competing requests follow a defined scheduling policy, and callers can cancel waiting requests or receive a failure when the allowed wait expires.
F7 Callers can terminate an environment and delete its resources, including retained disk state.
F8 Authorized callers can set which work may use their compute, which admission checks are required, and pause new environment assignments.
F9 Report how many requests are waiting for compute and how much capacity is available, so an autoscaler can decide whether to add or remove capacity. Waiting requests remain visible when capacity is zero.
F10 Report operation failures with a reason. If recovery cannot establish the outcome, report failure without assuming the operation had no effect.

Non-functional requirements

ID Requirement
NF1: Durability Service restarts must not lose accepted requests or stored results. Results remain readable for a documented retention period. This does not guarantee recovery of lost compute or disk state.
NF2: Safe retries Within the documented retry window, retrying the same request after a lost reply must not create another environment or execute the same operation again. A missing reply or failure must not automatically rerun work that may have executed.
NF3: Consistent state Concurrent requests and delayed messages must not produce conflicting assignments, undo termination, or change a final execution result.
NF4: Security Authenticate service connections and authorize access to environments, Runs, results, and configuration. Managers must prevent work in one environment from accessing another environment’s private processes, disk, or credentials, including environments belonging to the same workload owner. Protect credentials and sensitive data in transit and storage, and exclude them from diagnostics.
NF5: Controlled resource use Enforce documented limits on waiting requests, API payload size, execution duration, environment lifetime, connections, and retained data. Environment lifetime limits must apply even when the caller never requests termination. Reject excess load explicitly; slow clients must not block other work or cleanup.
NF6: Recovery After temporary connection failures or Environment Service restarts, restore communication with managers and tracking of accepted requests without duplicating execution. This does not guarantee restoration of lost environments or disk state. If an environment or execution outcome cannot be recovered, report failure with a reason.
NF7: Observability Expose enough status, errors, metrics, and diagnostic information to explain why work is waiting, failed, or awaiting cleanup.

High-level architecture

A Provider is a source of compute with access scopes, matching rules, and scheduling policy. Several Provider managers, shortened to managers, can connect under one Provider. Managers create environments and execute work, either directly or through another runtime. A Runner manager is one implementation.

An Admission Controller approves a proposed placement, rejects that Provider, or rejects the request. Required checks run before assignment; an unavailable controller is not approval.

Environment Service owns Provider and Admission Controller configuration, environment placement, and durable tracking of environments and Runs. After placement, one assigned manager is responsible for each environment’s operations and execution.

Deployment

Environment Service runs as a Relay module in its own Theseus deployment, with its own PostgreSQL and Redis. AutoFlow is a separate deployment. They communicate through service APIs, not shared databases or in-process calls.

Deployment details for Self-Managed and Dedicated remain to be specified.

flowchart TB
    AutoFlow["AutoFlow<br>Separate deployment"]

    subgraph AllCallers[" "]
        direction LR
        Callers["Callers<br>CI, CD, DAP"]
        ProviderConfigurationCallers["Authorized callers<br>Provider configuration"]
        ControllerConfigurationCallers["Authorized callers<br>Admission Controller configuration"]
    end

    subgraph Service["Environment Service replicas [1...N]"]
        API["Environment API"]
        Module["AutoFlow remote module"]
        Scheduler["Environment Scheduler"]
        ManagersRegistry["Provider Manager Registry"]
        ControllersRegistry["Admission Controller Registry"]
        ProviderConfiguration["Provider Configuration"]
        ControllerConfiguration["Admission Controller Configuration"]

        API -->|"create"| Scheduler
        Scheduler <-->|"checks / decisions"| ControllersRegistry
        Scheduler <-->|"assignments / capacity"| ManagersRegistry
        API <-->|"commands / results"| ManagersRegistry
        Module <-->|"requests / updates"| API
        ProviderConfiguration -->|"provider rules"| Scheduler
        ControllerConfiguration -->|"controller rules"| Scheduler
    end

    Managers["Provider managers"]
    Controllers["Admission Controllers"]
    Database[(PostgreSQL)]
    Redis[(Redis)]

    Callers <-->|"requests / results"| API
    Callers <-->|"workflows / outcomes"| AutoFlow
    AutoFlow <-->|"actions / channel updates"| Module
    ProviderConfigurationCallers -->|"create / configure"| ProviderConfiguration
    ControllerConfigurationCallers -->|"create / configure"| ControllerConfiguration
    ManagersRegistry <-->|"register / execute / report"| Managers
    ControllersRegistry <-->|"register / check"| Controllers
    Service <---->|"durable state"| Database
    Service <---->|"notifications / connection discovery"| Redis

    style AllCallers fill:transparent,stroke:transparent
    style Scheduler stroke-dasharray: 5 5

Callers use the API directly or run workflows in AutoFlow. Each manager or controller connection is held by one replica at a time.

The scheduler selects a Provider and manager for initial placement. Later operations use that assignment through the Provider Manager Registry, without scheduling again. Admission checks travel through the separate Admission Controller Registry.

The scheduler design describes matching, scheduling, and admission decisions.

Creating an environment

The caller describes the environment it needs and the work that will use it. Environment Service durably accepts the request and returns an environment ID without waiting for placement or creation. Acceptance does not mean readiness. Work can run once the assigned manager reports the environment ready.

sequenceDiagram
    participant Caller
    participant ES as Environment Service
    participant AC as Admission Controllers
    participant Manager as Assigned Provider manager

    Caller->>ES: Request environment
    ES-->>Caller: Environment ID
    Caller->>ES: Subscribe to environment status
    Note over ES: Scheduler waits for suitable capacity
    ES->>AC: Check admission through controller registry
    AC-->>ES: Approve
    Note over ES: Record assignment
    ES->>Manager: Create through Provider Manager Registry
    Manager-->>ES: Accepted
    Manager->>ES: Report environment ready
    ES-->>Caller: Environment update: ready

Creation continues independently of the caller’s connection or watch. A watch starts with the current state, so opening it later does not miss a retained outcome.

Environment definitions

An environment definition describes how to create an environment, including its images, resources, and initial setup. Many environments can use one definition, but each has its own ID, state, and Runs.

Callers may describe an environment directly or reference a reusable definition. Definitions can be managed outside Environment Service, without the service needing to understand runtime-specific formats.

Retries of an accepted request use the same definition version and artifacts. Matching and admission check the environment requirements whether supplied directly or through a definition.

Credentials for environment creation

Managers may need credentials to pull private images or configure services before any Run starts. These are creation inputs, separate from credentials used by work running in the environment.

The API does not yet define secure credential delivery, authorization, or refresh while requests wait for capacity.

Authorized scope matching

The caller supplies signed authorization context containing an opaque workload-owner ID, an authorized scope chain, and protected-work status. Environment Service verifies it and uses it for scope and protection checks.

A Provider passes the scope check when one of its allowed scope IDs appears in the verified chain. Environment Service compares IDs without resolving their hierarchy.

For example, work owned by scope-p42 may carry [scope-p42, scope-g7, scope-o3, scope-instance]. A Provider allowing scope-g7 passes the scope check. These are example identifiers, not a prescribed format.

The service applies current Provider rules and requires valid context for placement. Expired or invalid context cannot authorize creation. Admission Controllers add policy checks; they do not replace scope and protection checks. Renewing context must not create another request or reset its placement deadline. Refresh and revocation remain open.

The service records the workload owner at acceptance and checks access to existing environments and Runs against that ownership. Matching a Provider’s scope does not grant access to another owner’s resources.

Workload context

The environment specification describes compute, such as images and services. Optional workload context describes the intended work. Its repository identifiers are opaque to Environment Service and do not grant access.

Admission Controllers receive both workload and verified authorization context. They decide whether the information is sufficient, including when repository details are absent. Placement approval does not automatically authorize different work later in the environment.

Running work in an environment

A Run invokes one Function in a ready environment through its assigned manager. It does not require new placement.

User code runs inside the environment, not in the manager process. An integration may use a restricted manager-side handler to obtain inputs and dispatch work under the same Run. Only callers authorized for that integration may invoke the handler; user functions cannot invoke it.

Admission Controllers approve environment placement, not individual Runs. The caller remains responsible for the work it submits.

sequenceDiagram
    participant Caller
    participant ES as Environment Service
    participant Manager as Assigned Provider manager

    Caller->>ES: Submit work with environment ID
    ES-->>Caller: Run ID
    Caller->>ES: Subscribe to Run status
    ES->>Manager: Execute through Provider Manager Registry
    Manager-->>ES: Accepted
    Manager->>ES: Report progress and result
    ES-->>Caller: Run updates: status and result

Execution does not wait for a subscription. Subscribers receive the current status and any stored final result within the retention period.

Finishing or canceling a Run does not terminate the environment. Later Runs can reuse its disk state. Cancellation completes only when all work for that Run has stopped and delayed commands cannot start it later. Failure or timeout alone does not prove that work stopped.

A failed Run does not by itself make the environment unusable. If recovery cannot establish whether execution stopped, the environment accepts no new work and requires cleanup. It becomes failed unless termination is already pending.

Stopping, resuming, and terminating an environment

Stop and resume require support from the assigned manager. Stopping preserves disk state; resuming uses it through the same manager. Process memory and open connections are not guaranteed to survive. Lost disk state causes resume to fail, not create an empty replacement.

Terminate cancels an unassigned creation request or deletes an assigned environment and its resources, including retained disk state. It does not delete reusable definitions or shared artifacts. The environment cannot be resumed afterward.

An unassigned request can terminate without contacting a manager. Cancellation and assignment are checked together so canceled work cannot later be assigned.

If an assignment exists, including creation not yet confirmed, termination waits for confirmed cleanup on that manager. It remains terminating during disconnection or failed recovery; a timeout does not prove deletion.

Reaching an environment’s lifetime limit initiates termination under the same cleanup rules.

These requests acknowledge acceptance, not completion. Environment updates report completion.

sequenceDiagram
    participant Caller
    participant ES as Environment Service
    participant Manager as Assigned Provider manager

    Caller->>ES: Subscribe to environment status
    Caller->>ES: Request stop
    ES-->>Caller: Accepted
    ES->>Manager: Stop through Provider Manager Registry
    Manager-->>ES: Accepted
    Manager->>ES: Report stopped, disk state retained
    ES-->>Caller: Environment update: stopped

    Caller->>ES: Request resume
    ES-->>Caller: Accepted
    ES->>Manager: Resume through Provider Manager Registry
    Manager-->>ES: Accepted
    Manager->>ES: Report ready with retained disk state
    ES-->>Caller: Environment update: ready

    Caller->>ES: Request termination
    ES-->>Caller: Accepted
    ES->>Manager: Delete through Provider Manager Registry
    Manager-->>ES: Accepted
    Manager->>ES: Report resources deleted
    ES-->>Caller: Environment update: terminated

AutoFlow

AutoFlow is a durable workflow engine for multi-step automation. Workflows are written in Starlark and call services through actions provided by modules. AutoFlow records action results, timers, and incoming events so workflows can resume after restarts. Workflows can wait for external events or human input without keeping a worker running.

AutoFlow integration

An AutoFlow remote module in Environment Service exposes its lifecycle and Run operations as workflow actions. It connects to AutoFlow as an autoflow_module agent and uses the same service operations and stored state as the Environment API.

A workflow passes a channel() to create or run. The module saves the channel token with the accepted request and returns the environment or Run ID. It uses AutoFlow’s action idempotency key to return the same ID on retries, without another operation.

The channel supplied to create also receives later stop, start, and termination updates; run supplies the destination for that Run’s updates. The workflow waits for the required state with gather(c). AutoFlow persists the wait and releases the workflow worker until an update arrives. No polling or watch stream is needed.

sequenceDiagram
    participant Workflow as AutoFlow workflow
    participant AutoFlow
    box Environment Service
        participant Module as AutoFlow remote module
        participant API
    end

    Module->>AutoFlow: Register actions and open invocation tunnel
    Workflow->>AutoFlow: Invoke create with a channel
    AutoFlow->>Module: Action invocation with channel token and idempotency key
    Module->>API: Accept request and save notification destination
    API-->>Module: Environment ID
    Module-->>AutoFlow: Action result: environment ID
    AutoFlow-->>Workflow: Environment ID
    Note over Workflow: Wait for ready update in gather(c)
    Note over API: Wait for capacity and create environment
    API->>API: Save status update and record notification to send
    API->>Module: Deliver stored update
    Module->>AutoFlow: SendToChannel with stable idempotency key
    AutoFlow-->>Module: Accepted
    AutoFlow-->>Workflow: Deliver update and wake workflow

Stored environment and Run updates have increasing versions. The module sends them through SendToChannel, using an idempotency key for the resource, version, and destination. Delivery retries do not repeat execution. Consumers ignore stale versions; AutoFlow accepting a notification does not mean the workflow has consumed it.

Unlike watches, channel delivery retains pending notifications until accepted or ended under a defined policy. An unavailable AutoFlow must not block accepted operations or service-owned cleanup. Notification retention and expired-channel handling remain open.

The AutoFlow module guide lists remote-module credentials as roadmap work. Channel delivery from child workflows also needs validation before callers depend on it.

Failures and retries

Retrying a request is different from running work again. A caller may retry because it lost the reply, even though the service accepted the request.

  • Each state-changing request has a caller-supplied identifier. Within the retry window, repeated delivery returns the saved acceptance without another operation. Reusing that identifier with different arguments is rejected.
  • An accepted request remains tracked if the caller disconnects or the service restarts. The caller can reconnect and observe its status.
  • During a temporary disconnection, keep the last reported state or pending transition and show the assigned manager as unreachable. A lost reply does not permit assignment to another manager, even under the same Provider.
  • Unrecoverable loss becomes FAILED for environments or FAILURE for Runs, with a reason such as ENVIRONMENT_LOST, PROVIDER_MANAGER_LOST, or RUN_LOST. RUN_LOST means the execution outcome cannot be recovered. Termination remains pending until deletion is confirmed.
  • Failure does not prove execution stopped or had no external effects. Never automatically rerun that work.
  • The caller decides whether to submit new work after failure. That is a new request, not a retry of delivery.

FAILED means an environment is unusable and accepts no new work, not that its resources have been deleted. A failed environment has cleanup_pending = true while resources may remain. The service requests cleanup and retains its assignment and capacity reservation until deletion is confirmed. Automatic cleanup clears cleanup_pending and releases capacity but preserves FAILED.

A Terminate request instead moves the environment to TERMINATING, then TERMINATED with cleanup_pending = false after confirmed deletion. If a failed environment is already cleaned up, no further manager cleanup is needed. Neither path changes stored Run outcomes.

Final Run outcomes are immutable: a late success cannot replace a stored RUN_LOST failure. Late environment reports cannot make a failed environment ready, but can still confirm resource deletion.

State ownership and persistence

Owner State it keeps
Environment Service Provider and controller configuration, accepted requests and workload ownership, environment and Run IDs, Provider/manager assignments, pending commands, requested and reported state, versioned updates, pending channel deliveries, cleanup status, and execution results.
Provider manager Accepted command IDs, assigned environments and Runs, and results not yet acknowledged by the service.

Saving requests and results

The service saves each request before acknowledging acceptance. It records assignments and commands before delivery and uses those records during recovery without restarting work already finalized as failed.

Environment Service saves each channel notification with its status update in one database transaction. The remote module records delivery progress separately, so it can retry after a crash without losing updates or repeating operations.

Managers retain accepted command IDs and enough state to find their environments and Runs after a restart. They keep results until Environment Service acknowledges durable storage. They may then delete result payloads, but must still reject delayed commands within the retry window. Command ordering and replay protection remain open; permanent history is not required.

Requested state and reported state

A request does not prove that the environment changed. For example, after accepting a stop request, the service records that stopping was requested. It reports the environment as stopped only after the manager confirms it.

During a disconnect, the service shows the manager as unreachable while retaining reported state and pending transitions. Neither the retained state nor a later failure proves availability or resource deletion.

Recovering after reconnect

The service reconciles a reconnecting manager’s environments, Runs, and retained results with its saved assignments and unfinished Runs. New assignments and execution on that manager wait for recovery; cancellation and cleanup may proceed. Unrecoverable work is reported lost, not executed again; stored final outcomes remain unchanged.

Registration, connections, and health

Calls between replicas

A caller may reach any replica. State-changing requests are saved before acceptance; the replica holding the assigned manager’s connection delivers the corresponding commands.

Interactive execution needs live forwarding. Redis-based connection discovery and internal gRPC route the stream to the replica holding the manager’s connection. Admission checks use the same mechanism to reach a connected controller.

Providers

An authorized caller creates a Provider and configures its allowed scope IDs, matching rules, and scheduling policy. Manager registration does not create or change that configuration. The Provider remains configured when no managers are connected, so waiting demand remains visible.

Managers authenticate and register under an existing Provider using a stable manager ID. They reuse that ID after reconnecting and authenticate again. Reports and commands are bound to the authenticated registration; credential issuance and session binding remain open.

The registration type determines which environment specifications a manager supports. Runner registration supports the Runner specification. Capabilities are optional features, such as stop/resume and interactive execution.

Each manager opens an outbound connection to one Environment Service replica, so it needs no public endpoint. The choice between reverse gRPC tunnels and manager-initiated command streams remains open.

A manager receives new assignments only when its Provider permits them, its connection and capacity reports are current, and recovery is complete.

Admission Controllers

Admission Controllers authenticate and register separately from managers. They open bidirectional admission streams directly to Environment Service. Each stream carries one admission request and decision, then closes. A controller opens a new stream to wait for the next check. Controllers do not need a local gRPC server.

Registering a controller does not decide which work it governs. Scopes on the controller’s configuration determine which requests require its approval.

The scheduler applies controller scopes, enforcement modes, timeouts, and decisions. Required approval is never inferred from an unavailable controller.

sequenceDiagram
    participant Manager as Provider manager
    participant PMR as Provider Manager Registry
    participant AC as Admission Controller
    participant AR as Admission Controller Registry

    Manager->>PMR: Authenticate and register manager ID, type, and capabilities
    PMR-->>Manager: Provider, manager, and session IDs
    Manager->>PMR: Open reverse connection
    Note over Manager,PMR: Compare saved state before new assignments
    Manager->>PMR: Report capacity periodically

    AC->>AR: Authenticate and register
    AR-->>AC: Registration accepted
    AC->>AR: Open admission stream
    AR->>AC: Admission request
    AC-->>AR: Decision

Capacity

A manager reports the total number of environments it can host. Environment Service uses that limit and its assignments to calculate available capacity for that manager, then aggregates it by Provider. Managers manage CPU, memory, and other resources internally.

  • Recording an assignment reserves capacity before the manager receives or accepts the creation command, so another assignment cannot use the same slot.
  • The manager checks its own capacity before accepting creation.
  • A confirmed creation rejection without creating resources releases the reservation; an uncanceled, unexpired request may return to waiting. A missing reply does not release the reservation.
  • Confirmed deletion releases the environment’s reservation.
  • Failure alone does not release a reservation; resources may still exist or execution may still be running.
  • A disconnected or unhealthy manager receives no new assignments. Its existing reservations remain recorded.

Managers include accepted creation commands in their creating count, even before resource creation starts.

API

The API specification defines caller operations, Provider manager registration and commands, Admission Controller checks, and configuration.

Open questions

Execution and lifecycle

  • Should managers receive commands through a reverse gRPC tunnel to a local server or manager-initiated streams like Admission Controllers?
  • How should the service handle a stop or resume rejected by the manager after caller acceptance, for example because another lifecycle operation is in progress?
  • When does a Run’s timeout start: service acceptance or execution? Should manager commands carry a duration or an absolute deadline, and how is the original limit preserved across retries?
  • After a lost reply, should delivery resend the command or query the manager? How are delayed commands rejected after cancellation, termination, or result acknowledgement without permanent manager history?
  • When should a manager acknowledge a Run: after accepting it or only after execution starts? How should accepted work that has not started appear during recovery?
  • Does Run SUCCESS mean the Function succeeded, or that execution completed with a result even if the Function failed? How should Function errors and process exit codes be represented?
  • How should function references, inputs, and results align with the final Function API? How should managers report supported built-ins and versions?
  • Can Runs execute concurrently? What should stop do during an active Run, and how does termination or environment expiry stop active work?
  • Should stop or cancellation have a caller-configurable grace period? What happens when it expires?
  • How should repeated lifecycle requests behave when the environment is already stopped, ready, or terminated?
  • What happens to an Exec process when its stream disconnects or the environment terminates? How does a caller close stdin while continuing to receive output?
  • How should callers access execution logs? Should Environment Service provide them, or should an existing log service handle storage and delivery?
  • How should stopped environments count against manager capacity, and when must resume wait for capacity?
  • What environment lifetime limits apply, when do they start, and can callers extend them? How are compute and retained-disk limits enforced while a manager is disconnected?

Authorization and configuration

  • How should authorization context be renewed or revoked while a request waits? How are owner, scope-chain, protected-work, and required integration checks bound to accepted requests?
  • How is stored workload ownership used to authorize later operations without reinterpreting changed scope chains?
  • How do callers obtain a trusted Provider, manager, and placement identity for an accepted environment? The watch draft reports state but not placement details.
  • How are credentials for environment creation delivered and refreshed securely? The draft has no credential fields or reference contract.
  • How are reusable environment definitions referenced, resolved, and authorized? Who keeps their revisions and shared artifacts available while accepted requests or environments depend on them?
  • What additional workload context do matching and admission need as other callers adopt the service?
  • Should workload context include a principal or actor on whose behalf the environment is requested? How does it relate to the authenticated calling service?
  • Do any required policies need to inspect each Run before execution, rather than only environment placement?
  • How should existing runner-scoped controllers and their REST APIs map to Provider scopes and this configuration API? Who may manage each scope?
  • How should Provider and controller deletion work while environments, managers, or pending checks still reference them?
  • Which manager execution modes meet the environment isolation requirement?
  • Which existing authentication mechanisms should callers, managers, controllers, and replicas use? How are credentials issued, rotated, revoked, and bound to registrations, including managers outside GitLab’s clusters?
  • How are registration session IDs bound to authenticated calls, and how are stale sessions rejected? How are commands already received by an old manager session accounted for? How do controller sessions support multiple running instances without accepting stale decisions?

Recovery and operational limits

  • What limits and defaults apply to API payload sizes, waiting requests, creation time, Run duration, and result retention?
  • How long can callers retry the same request? How long should recovery continue before unfinished work is failed? Termination and cleanup stay pending until deletion is confirmed.
  • How should operators handle resources whose deletion cannot be confirmed because their manager never returns?
  • What request volume, latency, availability, and recovery targets must the service support?
  • What retention and retry limits apply to AutoFlow notifications? How are expired channels replaced, and how can another workflow subscribe to an existing environment or Run? The drafts do not yet define that recovery contract.

References


Environment Service: API
Proposed APIs for Environment Service callers, Provider managers, Admission Controllers, and configuration.
Environment Service: Scheduler
How the scheduler matches requests to Providers and managers, orders waiting work, and obtains admission before assignment.
Last modified November 17, 2026: Environment Service Blueprint (447b7f91)