The Laptop Is No Longer the Runtime

A cloud agent is not a chatbot with a longer timeout. It is a remote worker with a computer, a policy boundary, and a handoff. The recent acquisition rush makes more sense once you see which pieces of that worker the model companies still do not own.

# how a cloud agent actually works

A cloud agent is a remote job system wrapped around a model. The model chooses actions, but the surrounding system creates the computer, supplies context, controls permissions, executes tools, checks the result, and returns something a human can review.

GitHub repo → isolated cloud workspace → inspect/edit/test loop → branch or PR → cleanup

01
authorize the repository— A GitHub App or token grants scoped access; the human selects the repository and starting branch or commit.
02
receive the job— A prompt, issue, schedule, PR comment, or API call becomes a bounded task with a definition of done.
03
provision a remote computer— The service starts an isolated container or VM for this job, with explicit CPU, memory, network, and credential limits.
04
materialize the source— The runtime clones or fetches the repository and checks out the selected ref into a disposable working copy.
05
hydrate the environment— A base image or devcontainer restores dependencies and caches, starts required services, and attaches approved tools and secrets.
06
assemble context— Load project rules, relevant code, history, and the task contract.
07
inspect, edit, and run— The model requests a tool; policy checks it; the runtime reads files, applies edits, and runs commands.
08
observe and repeat— Command output, test failures, and file changes return to the model: inspect → edit → run → observe, until done or stopped.
09
prove the result— Run tests, type checks, builds, screenshots, or domain evaluators.
10
publish the handoff— Return a patch or diff; with write permission, push a branch, commit changes, or open a pull request.
11
retain evidence and clean up— Preserve logs, artifacts, checkpoints, and the final status, then destroy an ephemeral sandbox or reset a persistent one.

GitHub remains the source of truth. The agent works on a remote copy and can write back only through the permissions it was given.

The agent never edits the canonical repository “inside GitHub.” It works on a remote copy. GitHub stays the source of truth, and changes return as a patch, commit, branch, or pull request only when the job has write permission.

ephemeralA fresh sandbox and clean checkout for every task. It is the safest default: finish the handoff, preserve the evidence, then destroy the machine.

persistentThe repository, dependency cache, or whole workspace survives between tasks. Startup is faster, but stale state, credential lifetime, and workspace drift need stronger controls.

read-onlyThe worker may inspect, edit, run, and return a diff without receiving permission to push anything upstream.

write-backWith narrowly scoped permission, the service can push a task branch, create a commit, or open a PR. Protected branches and human review still remain in force.

The model is active only in the middle of this lifecycle. Everything before the loop makes the task reproducible; everything after it makes the result reviewable and trustworthy. That is what lets the worker continue safely after the laptop closes.

Ona interface showing background coding agents beside a cloud development environment — Ona's official product image: background agents on the left, a reproducible development environment on the right. Image: Ona.

# the acquisition is the architecture diagram

On June 11, 2026, OpenAI announced that it would acquire Ona. The transaction closed on August 10, and Ona joined the Codex team. The interesting part is not the logo combination. It is what OpenAI bought: secure, persistent, customer-controlled cloud environments where an agent can keep working after the laptop closes.

Ona began with cloud development environments and moved toward background agents. That history matters. A capable model can propose the next action, but it still needs somewhere to clone a repository, install dependencies, reach internal systems, hold credentials, run tests, persist state, and leave an audit trail. Ona had spent years on exactly that unglamorous layer.

“Agents need more than intelligence; they need a trusted workspace.”
share this line

That sentence from the acquisition announcement is the entire cloud agent market in nine words. OpenAI supplies intelligence and orchestration. Ona supplies the governed place where that intelligence can act. The official announcements from OpenAI and Ona make the split unusually explicit.

# what consolidation is actually buying

The market headlines look random: a model lab buys a JavaScript runtime; another buys Python tooling; a coding company buys an IDE; OpenAI buys a cloud-environment company. Read them as stack layers and the strategy becomes obvious.

Selected agent-stack transactions, 2024–2026

Nov 2024 Cursor← Supermavencompletion model and editor talentjoined Jul 2025 Cognition← Windsurfagentic IDE and distributionacquired Dec 2025 Anthropic← Bunruntime, package manager, and testsacquired Feb 2026 Anthropic← Verceptcomputer perception and interactionacquired Mar 2026 OpenAI← AstralPython toolchain: uv, Ruff, and tyannounced May 2026 Anthropic← StainlessSDKs and MCP connectivityacquired Aug 2026 SpaceX← Cursorcoding surface and expert distributionclosed Aug 2026 OpenAI←

Onapersistent, customer-controlled cloudclosed

Anthropic illustration of one block joining another — The artwork accompanying Anthropic's Bun acquisition announcement. Image: Anthropic.

# read the deals vertically

The common thesis is not that every company wants another chat interface. They want control over the path from intent to verified work. Each acquisition removes a dependency from that path.

surfaceWindsurf · Cursor · Supermavenwhere intent enters and review happens

connectorsStainless · MCPtyped paths into real systems

toolchainBun · Astralinstall, run, lint, test, and verify

interactionVercept · computer useoperate software without a clean API

workspaceOna · cloud sandboxesisolation, persistence, governance, and audit

Anthropic acquiring Bun gives Claude Code deeper ownership of the runtime, package manager, bundler, and test runner underneath JavaScript work. Stainless adds generated SDKs and MCP connectivity. Vercept adds the perception and interaction layer for software that cannot be reached cleanly through a shell or API.

OpenAI's announced Astral acquisition reaches into uv, Ruff, and ty: dependency management, linting, formatting, and type checking for Python. Ona reaches below all of that into the workspace itself. Models are getting better, but the durable moat is becoming the complete execution system around them.

# why the cloud changes the unit of work

A local agent borrows my attention. A cloud agent borrows my specification. That is a much harder interface. If I cannot state what “done” means, background execution only lets the misunderstanding run for longer.

local

Live worktree, local services, and instant steering. Best while the problem is still becoming clear.

cloud

Reproducible workspace, asynchronous execution, parallel capacity, and governed credentials. Best once “done” is testable.

Parallelism becomes cheap. Three independent tasks can occupy three environments without fighting for the same working tree or laptop resources.
Reproduction becomes a product feature. The environment definition is reusable by the next agent, reviewer, and human—not tribal knowledge trapped in shell history.
Governance becomes enforceable. Credentials can be scoped per job, network access can be explicit, and every tool invocation can become an auditable event.
Handoffs become asynchronous. The task can begin in an issue and end as a PR without keeping the initiating device awake.

# the task packet is the real prompt

“Fix the writing page” is a conversation starter. It is not a cloud task. A delegatable task names the outcome, narrows the blast radius, declares non-goals, supplies verification, and defines the artifact that comes back.

outcome: Two source-backed field notes render locally and stay readable on mobile.
scope: app/writing/**, components/writing/**, public/agent-blogs/**
non-goals: No CMS and no unrelated dependency or homepage work.
proof: Lint, production build, and a visual pass at mobile and desktop widths.
handoff: Changed files, evidence, known limitations, and a clean diff.

This is the packet I would use for the field-note system you are reading. Notice that it does not prescribe every edit. It gives the agent freedom inside a box whose edges are observable.

don't

Give the agent a persona and hope it behaves like a senior engineer.

Give it a bounded objective, an environment, permission limits, checks, and a stopping rule.

Personality changes the prose. Contracts change the probability of a safe handoff.

# a worked delegation path

01Human frames the result. Two locally rendered, source-backed essays; centered at every breakpoint; official imagery; legacy URLs preserved.
02Cloud worker provisions from a clean commit. It installs the locked dependencies and confirms the baseline build before making a change.
03The agent maps existing patterns. It finds the typed writing data, the legacy blog route, the product-topic article kit, and the global layout rails.
04Implementation stays inside the declared scope.Article routes, shared visuals, metadata, navigation, and local assets are changed together.
05Verification produces evidence. Lint and build pass; mobile and desktop screenshots show the column centered; every external claim points to a primary announcement.
06A human reviews the taste layer. The final call is not whether JSX compiled. It is whether the story feels authored, whether the visual rhythm holds, and whether any claim overreaches its source.

# where cloud agents still fail

Environment parity is never automatic

A reproducible environment can still reproduce the wrong thing. A missing seed, private package, service dependency, browser state, or architecture-specific bug can make a clean cloud run misleading.

Long-running does not mean long-context

Hours of logs and tool output are not useful memory. The harness must compact aggressively while preserving the task contract, decisions, failures, and verification state.

Parallel work creates merge topology

Independent tasks are only independent until they edit the same boundary. Worktrees and branches isolate files; they do not resolve competing architectural decisions.

A green test suite can prove the wrong thing

Verification is only as strong as the acceptance criteria. If a UI change has no screenshot or interaction pass, npm test may be a beautifully automated lie.

# what stays local

I keep work local while I am discovering the shape of the problem: reproducing an intermittent bug, feeling animation timing, reading a messy working tree, or changing architecture through conversation. Once the outcome is crisp and the proof is executable, the task becomes a candidate for the cloud.

the decision rule

if (problem.isStillFuzzy) {
  workLocal();       // steer quickly, use live state
} else if (done.isMachineCheckable) {
  delegateToCloud(); // isolate, parallelize, return evidence
} else {
  keepHumanInLoop(); // taste, architecture, irreversible calls
}

# three official Ona frames

The visual evolution tells the same story as the product: background notification, full cloud workspace, then the acquisition that connects that runtime to Codex.

Ona background agent notification — A task returns while the human is elsewhere—the smallest possible cloud-agent interface. Image: Ona.

Ona is joining OpenAI announcement artwork — Ona's acquisition announcement. The transaction closed on August 10, 2026. Image: Ona.

# the durable takeaway

Cloud agents are not winning because the cloud makes the model smarter. They are winning because serious delegation requires infrastructure: a reproducible computer, scoped authority, persistent state, observability, verification, and a reviewable return path.

That is why model companies are buying runtimes, toolchains, connectors, interfaces, and workspaces. The model is becoming one layer in a much larger software system—and the companies that own the whole path can turn intelligence into reliable work.