Coding agents – that is, AI assistants that not only suggest code but carry out tasks independently across multiple steps – have so far mostly been tied to the developer's machine. If an agent runs locally, it only runs as long as the laptop is open and connected. This is exactly where a current development comes in: Docker is providing cloud sandboxes for coding agents. Longer tasks can thus be moved from the local device to the cloud.
In this context, a sandbox is an isolated execution environment in which a program – here the agent – can work without having direct access to the rest of the system. At Docker, this isolation via containers has been the core principle for years. What is new is that this environment no longer has to be on your own machine.
What changes technically
The practical consequence is modestly phrased but noticeable in work organisation: an agent working on a task over a longer period remains active even when the work session on the computer ends. Tasks that were previously tied to the presence of the developer can be decoupled.
This also shifts the role within the team. Instead of accompanying an agent during execution, a task is handed over and the result is checked later. This is more similar to handling build or CI processes – that is, automated workflows that run in the background – than to interactive use of an assistant in the editor.
The editor is moving too
In parallel, a roundup from the developer scene reports new agent features in Visual Studio Code. The report summarises several smaller innovations from various ecosystems, including Laravel, Symfony, PyPy, Azul, Google, GitLab and Sublime Text. The source does not elaborate on the details of the VS Code agent features, so caution is appropriate here.
What is particularly noteworthy is the simultaneity: on the one hand, the runtime environment shifting to the cloud; on the other, the editor further expanding agent features. Both point in the same direction – agents should take on more tasks and work independently for longer.
Why isolation is the real point
An agent that writes code, installs dependencies, runs tests and modifies files needs extensive permissions in its environment. On a developer's machine, that means in the worst case: access to credentials, to other projects, to the corporate network. A defined, delimited execution environment reduces this attack surface because it is clearly specified what the agent can access in the first place.
From an IT security perspective, this is less a comfort question than a governance question. Anyone using agents productively should be able to describe the environment in which they run: which network accesses are permitted, which secrets are available, how long a run may last and how results get back into version control.
What teams should clarify now
- Data flow: Which repositories and which data leave your own machine when an agent works in a cloud environment?
- Credentials: Which tokens and keys does the sandbox receive, and how tightly are their permissions scoped?
- Review: Who checks the result of an unsupervised run before it goes into a branch or even a release?
- Cost: Longer runtimes in the cloud cause costs that behave differently from local computing time.
- Traceability: Can it be reconstructed afterwards which change came from which run?
Realistic expectations
The reports available describe a direction, not established practice. How well outsourced agent runs fit into existing development processes depends heavily on the respective project: on test coverage, on the quality of the task description and on how deterministic a build behaves.
Experience shows that tasks with clear boundaries are well suited: updating dependencies, recurring refactorings, expanding test coverage, preparing migration steps. Anything that requires domain decisions that are not documented anywhere is poorly suited. An agent in the cloud accelerates good preparatory work – it does not replace it.
Assessment for web and software projects
For client projects, the development above all means: the execution environment becomes an explicit part of the project architecture rather than a by-product of the developer laptop. Anyone who wants to delegate tasks to agents needs clean container definitions, robust tests and a clear review process – in other words, the same foundations that make a stable project even without AI. The realistic gain lies in shorter turnaround times for clearly delimited routine tasks, while architecture and domain decisions remain with the team.
Sources
- Laptop zu, Agent arbeitet weiter: Docker Sandboxes ziehen in die Cloud — heise developer News
- Developer-Häppchen – Google KI-Abos, GitLab-Lücken und VS-Code-Agenten — heise developer News