There was a look you could spot at any tech conference in 2025: an engineer walking through the halls carrying a laptop cracked open at hip level, carefully, like a tray of water glasses. At the airport. At the ice rink during the kid's practice. Binder clips on the hinge to keep the lid from closing all the way. The behavior was so recognizable that Business Insider wrote it up and even OpenAI's social accounts got in on the joke. Closing the lid killed the agent loop and killed whatever the agent was working on, so the lid stayed open.

That was a year ago. It feels archaic now.

The problem before the products caught up

Through 2024 and into early 2025, coding agents lived inside your IDE or your terminal. They ran on your clock, on your machine, in your process. If the laptop slept, the agent stopped. If you wanted to check on it, you walked back to the desk.

If you used more than one agent product — and by mid-2025 most serious practitioners were running Cursor and Claude Code at minimum, often Codex as well — you were the integration layer. You switched tabs, copied context from one conversation into another, and babysat every session individually. The agents could not see each other's work. They did not know each other existed.

I built Kanbus to solve the part of this problem that was solvable without waiting for vendors. The idea was simple: if every issue is a JSON file inside a Git repository, then any agent that can clone the repo can read the board and write to it. Git is the transport. The repository is the shared memory. A Cursor agent on my laptop, a Claude Code session in the cloud, and an Codex environment I have never seen — they all speak Git, so they all speak Kanbus.

You do not need Kanbus for this. Jira works. Linear works. Slack works, crudely. Anything reachable from every agent platform on your list works as a common channel. What Kanbus gave me was that the backlog traveled with the code: the ticket branched, diffed, and got reviewed in the same pull request as the change that closed it. But the essential insight was smaller than the tool. The insight was that agents on different products and different computers could coordinate through a shared record, and the shared record did not have to be anything exotic. It just had to be something every agent could reach.

That coordination layer mattered because the products were not going to solve it for me. Each vendor was building remote execution for their own agents, inside their own walls. None of them were building a way for their agents to talk to someone else's.

The vendors start reaching for remote

Through late 2025 and into early 2026, the cloud sandboxes started appearing. Cursor shipped cloud agents — isolated VMs where your agent ran on Cursor's infrastructure instead of your laptop. Codex launched with parallel cloud environments from the start. Claude Code added cloud sessions. The compute moved off the laptop.

But the interaction model did not change. You still sat at the terminal or in the IDE, queued a task, watched tokens stream, reviewed the diff, and queued the next thing. Moving the execution to a cloud VM solved the "my laptop fans are screaming" problem, not the "I am chained to this computer all day" problem. The agent still waited for you, and you still waited for the agent.

Setup was often difficult. Reliability was uneven. Capabilities were limited. If your project needed access to your local test database, a hardware device on USB, or a VPN tunnel to a staging environment, the cloud sandbox could not reach any of it. Remote execution without remote control just moved the waiting to a fancier computer.

2026: the three trends that converged

What changed was not one thing. Three trends hit at the same time, and they multiplied.

Cheaper tokens made long loops viable. The economics of running an agent for twenty-five uninterrupted turns — with input tokens outnumbering output tokens twenty-five to one — went from "impressive demo" to "line item." The Year Coding Became a Commodity makes the full case. The short version: the same budget that bought one interactive assistant in early 2025 buys a standing team of concurrent background agents in 2026.

Agents got better at running long. A year ago, a coding agent would make one change and stop, waiting for you to read the diff and push a button before it would do anything else. In 2026 the best agents run through tests, notice failures, try corrections, run the tests again, and come back with a working branch or an honest account of where they got stuck. The agent's useful working time stretched from minutes to hours — sometimes overnight. That changed what it even meant to "use" a coding agent. It stopped being a conversation and started being a delegation.

The harnesses shipped real remote orchestration. Not just "run in the cloud" — actual scheduling, event triggers, and control surfaces you could reach from your phone while you were out living your life. This is where 2026 got specific.

What arrived and when

Cursor went the furthest the fastest. Cloud agents already existed, but in 2026 they added Automations — presets, cron expressions, and event triggers from GitHub, GitLab, Slack, Linear, Sentry, PagerDuty, and raw webhooks. Then came self-hosted workers: you run agent worker start on your laptop, a devbox, or a pool machine, and Cursor's cloud orchestrator sends tool calls down to your hardware. The agent loop lives in the cloud; the shell commands, file edits, and test runs happen on a computer you control. You can orchestrate all of this from your phone while you are out in the world, instead of sitting chained in front of your computer all day.

Antigravity shipped Remote Control on August 21, 2026 — a browser window onto a session running on hardware you own. Its Scheduled Tasks take a cron expression, and sidecars expose a schedule builtin with the same five-field cron. The tradeoff is explicit: Google gives you the window, you supply the computer. If your machine sleeps, the agent sleeps.

Claude Code added cloud sessions on Anthropic-managed infrastructure, Remote Control as a window onto a running local CLI, and Routines — a research preview with schedule and event triggers, capped at one run per hour with a daily allowance on top of subscription limits. The split is subtle: cloud sessions survive a closed laptop, Remote Control does not, and from the outside they both look like "use Claude Code from your phone."

Codex shipped cloud environments and scheduled tasks with the finest granularity in the group: minute intervals, daily and weekly times, full RFC 5545 recurrence rules, plus Gmail, Slack, and GitHub event triggers. But it splits by surface: a scheduled task created on the web runs server-side, and the same task created in the desktop app needs the computer on and the app running.

Grok Bot arrived on August 11, 2026 with an always-on cloud computer scoped to your account. It runs routines on a schedule and fires from event triggers. The laptop can be closed, the machine can be off, the routines keep running. And it sits inside the Cursor ecosystem, so a Grok Bot chat can launch a Cursor cloud agent — which means the always-on bot can dispatch work to a product that actually has repository access.

Why the convergence mattered

Any one of these trends alone would have been interesting but not transformative. Cheaper tokens without better autonomy just means cheaper one-shot diffs. Better autonomy without cheaper tokens means impressive but expensive demonstrations. Better autonomy and cheaper tokens without remote orchestration means your laptop still has to be open.

Together, they changed the daily operating shape of the work. You now routinely have multiple parallel agent tasks running as you go about your day — one working through a refactor, one running a test matrix, one drafting documentation. If you cannot check on them from your phone, you lose hours of compute time while agents sit idle waiting for your review or your next instruction. The engineers who were walking around with laptops in 2025 were not wrong about needing constant access to their agents. They were just solving it with hardware when the real solution was infrastructure.

The comparison

Two questions sort the five harnesses better than any feature list:

Whose computer runs the tool calls? Not where the model runs — every one of these does inference in a vendor cloud. The question is where the shell commands, file edits, and test runs happen, because that determines whether the agent can see your dirty working tree, your private network, and the microcontroller you have plugged into USB.

Whose clock starts the run? Yours, or the harness's.

Hopper and actor

A hopper is a queue with a worker attached. You put a task in, the work happens somewhere, the result comes back, and nothing else happens until you put in another task. Where the compute lives is an implementation detail. The shape is the same: the agent is idle until you act.

An actor has a trigger it owns. A schedule, a webhook, a pull request opening, an alert firing. Nobody is standing at the hopper. The work starts because a condition the agent was watching became true, and you find out afterward.

That is the distinction 2026 actually shipped. "Remote" was the visible feature and the one every launch post led with, but remote by itself just moves the hopper to a fancier computer. The scheduling and event triggers that landed alongside it are what turned these products into things that run when you are asleep.

A hopper is a 2025 object. An actor is a 2026 one.

The cost of actors is not obvious until you live with them. A hopper hands you a diff you asked for. An actor hands you a diff you did not ask for, produced by a run you did not watch, against a condition you configured some weeks ago and no longer remember precisely. The review load arrives in a shape most of us have not built habits for.

And obedience matters much more than it used to. When you are sitting in the loop, an agent that ignores your written procedure is an annoyance — you notice, you correct it, you move on. When the agent starts itself at 3 AM, the procedure written down in AGENTS.md is the only supervision in the room.

On that axis my experience does not match the marketing, and I want to be clear that this part is subjective and not verifiable from anyone's documentation. Codex is the most reliable at following a written procedure it was not reminded about in the last message. Claude Code is next, which is faint praise given how often it needs reminding. Grok Bot is the least reliable of the five and the most willing to substitute its own interpretation, which is an uncomfortable pairing with being the harness that runs most freely while nobody is looking.

They still cannot share a working tree

Five harnesses, five checkouts. Cursor's cloud VM, Anthropic's cloud VM, Codex's cloud environment, your Antigravity host, and the Grok Bot computer are five different filesystems, and no amount of remote execution merged them. Two agents in two products cannot open the same dirty tree, so the collaboration model between harnesses is the one that works: commit, push a branch, wait.

What does cross the wall is a shared record. Kanbus is the one I use — Git as the transport, issues as messages, one file per task, so every agent that can clone the repository can read the board and write to it. Jira works for this too. So does Linear, Slack, or anything else every platform on your list can reach. The requirement is not a particular tracker. It is that the tracker is legible to the agent on your laptop, the agent in someone else's cloud, and the agent on the machine you never see.

That shared record is what makes the weakest-linked harness useful. Grok Bot is always available and reachable from a phone, and it is the one I trust least with a repository. Those two facts stop conflicting once it can file an assignment instead of making a change: it takes the note, writes the issue, and stops. A harness I do trust picks the issue up and does the work. The organizational argument that follows from this — reporting lines, review gates, who is allowed to reject work — belongs in From pair programmer to executive.

Shared memory is not a shared checkout. It is enough.

Practical notes

Commit and push far more often than felt necessary in 2025. A cloud computer can go away between one message and the next, and a recovery point on a disk you cannot reach costs you the recovery time even when it works. The remote you can count on is the one on GitHub.

Check the "closed laptop" column before you build a routine on a harness. Two of these five will quietly stop running when your machine sleeps, and neither of them warns you at configuration time.

Put the procedure in the repository, not in the conversation. An agent with its own clock has no conversation to read when it starts.

And when you evaluate the next one of these, skip the remote-execution bullet. Every product in the category has it now. Ask what starts a run, what happens to that run when you close the lid, and whether the thing that starts itself at 3 AM can be trusted to read the file you wrote telling it what not to do.

The question is no longer "can I run this agent somewhere other than my laptop?" It is "can I run it from my phone while I am living my life?"