Chinese
Uncategorized

GitHub Copilot Cloud Sandboxes: The Real Work Is Resuming and Budgeting

GitHub’s Copilot cloud sessions add resumable sandboxes. The useful question is how to control state, permissions, and spend.

Jacky Wang 4 min read 51 views

Last week I was thinking about a practical failure mode: if an agent keeps working after I close my laptop, where exactly do I resume the job the next morning? GitHub’s new Copilot cloud experience is designed around that hand-off. A session can start on github.com, GitHub Mobile, the CLI, VS Code, or the Copilot app, and it can continue on another surface. By default, the work runs in a GitHub-managed cloud sandbox. When the sandbox shuts down, GitHub saves a snapshot so the session can be resumed later.

That is more interesting than simply putting a terminal in the cloud. The sandbox combines repository context, tools, permissions, and session state. For a small personal repository, that can feel like a clean convenience. For the kind of projects I run—SaaS services, Kubernetes manifests, and deployment scripts in the same general workflow—it means I want a boundary before I want more autonomy.

Start with the tool boundary

GitHub says cloud sessions can use Bash, the GitHub CLI, code search, connectors, MCP servers, and custom skills. The agent asks for approval before a tool call that requires it. That makes permissions a combination of repository policy, organization settings, connected services, and the session itself. A local shell permission model is no longer the whole story.

For a new repository, I would start with a deliberately narrow setup step that installs dependencies, runs tests, and checks the diff:

name: copilot-setup-steps
steps:
  - run: pnpm install --frozen-lockfile
  - run: pnpm test
  - run: git diff --check

This is my conservative starting pattern, not a claim that GitHub requires this exact file. Production credentials stay out of the sandbox. Deployment commands stay out of the default path. If a task needs a Kubernetes change, I want the agent to produce a manifest diff and evidence first; I can run the release process separately.

A snapshot fixes interruption, not dirty state

The cloud sandbox is useful for long-running work. GitHub says it is not limited by the local machine’s compute, and it does not impose a one-hour total session limit. When the sandbox stops, the snapshot lets me pick up the same work later. That is a good fit for asking an agent to investigate a failing test overnight and reviewing the result in the morning.

Still, resumable does not mean reproducible. An agent may leave uncommitted files, create a temporary database, or install a dependency after reading an external service. A snapshot preserves that point in time; it does not replace lockfiles, isolated test data, or an explicit commit boundary.

I would treat each session like a disposable build machine with a timestamp. At the start, record the branch and baseline. At the end, accept one of three outcomes: a reviewable commit, a clear failure log, or an experiment report that did not write to the repository. “The session is still alive” is not a quality signal.

Shared compute makes retries a budget decision

GitHub is also turning included Actions compute into a shared dollar-based pool. The same entitlement can cover standard hosted runners, cloud sandboxes, and, for some plans, larger hosted runners. GitHub says billing for cloud sandbox usage begins in November 2026 and draws from that shared entitlement.

That changes the operational question. A failed CI job used to be mostly a waiting problem. A chain of automatic retries, a long debugging session, and a large dependency install can now consume the same team pool. For a small team, I would start with a plain rule: one automatic retry per task, then save the logs and stop. Continuing should be an approval step.

My view is that the useful part of Copilot’s cloud experience is not moving every line of development away from the laptop. It is giving interruptible work a tracked place to run. I would use it first for tests, dependency updates, and read-only investigation. For production writes, I still want the sandbox to stop at the diff and the evidence.

There is another small risk in the cross-device story. A short instruction sent from a phone can become a much larger code change when it is resumed in a browser. I would put the target files, forbidden directories, and acceptance commands in the first prompt, then preserve the test output with the session result. Fast resumption is useful, but understanding the restored state comes first.

Primary references: GitHub’s cloud Copilot changelog and the GitHub Copilot coding agent documentation.

发表评论