---
title: "Connecting Cloud and Local AI Development Workflows with Loop"
description: "I built a desktop app called Loop that connects Cursor Cloud Agents, local Codex and my own review in one loop until the PR is merged"
canonical_url: https://ro.yikzero.com/en/blog/loop-cloud-local/
locale: en
date: 2026-11-01
---

# Connecting Cloud and Local AI Development Workflows with Loop

## Introduction

A while back I got a good deal: SuperGrok Heavy is normally $300 a month, and I caught a promotion that gave me a year for about $900. Early on it also came with Cursor Ultra. They [stopped including it](https://forum.cursor.com/t/is-supergrok-heavy-now-the-better-cursor-ultra-deal/168558) later, but people who already claimed it kept it.

Having paid for it, I didn't want the quota to sit unused, so I started handing as much of my everyday feature work as I could to Cursor's Cloud Agents.

After a while I was barely writing code, but my time went into **going back and forth between the cloud and my machine**: file the request, read the plan, wait, pull the branch to run the simulators, change two lines, push it back, then read the PR reviews... I'd gone from writing code to carrying messages (lol).

So I built Loop. A feature usually goes between the cloud and my machine several times before the PR is merged, and Loop now manages those handoffs.

## What Is Loop

Loop is a macOS app based on the open-source version of [Craft Agents](https://github.com/craft-ai-agents/craft-agents-oss), which I modified with the help of Codex and Claude. Craft already has a good desktop UI and chat, so I added a task-delivery layer on top:

- Cloud: Cursor's Cloud Agents write the plan, the code and the PR follow-ups
- Local: each task gets its own worktree and terminal, and chat runs on the Codex installed on my machine
- Other: GitHub uses my local `gh` login, and Jira tickets can be linked to tasks

It opens on a board with three columns: "Needs me", "Processing" and "Ended". Most of the time I only look at the left column and let the cloud get on with the rest:

![Loop overview: Needs me, Processing, Ended](https://cdn.yikzero.com/markdown/images/loop-overview-20261101.png)

Using AI to build a tool that manages AI doing work... at this point, who's working for whom?

## How Models Split the Work in Loop

Roughly, the cloud writes code and follows the PR, and I review and decide locally. In detail:

| Step | Who Does It | Where |
| --- | --- | --- |
| Draft plan | Claude Opus 5.5 (high) | Cloud |
| Review plan | Me | Loop |
| Write code | Grok 4.7 (xhigh) | Cloud |
| Testing, desktop & Web verification | Grok 4.7 (xhigh) | Cloud |
| iOS & Android verification | Me | Local |
| Fix what doesn't match my expectations | Codex (GPT-6 Astra, Extra High) | Local |
| Handle PR reviews & CI | Grok 4.7 (xhigh) | Cloud |
| Product decisions & merge | Me | Loop |

For a general sense of where these models stand, check out [Artificial Analysis's Intelligence Leaderboard](https://artificialanalysis.ai/#intelligence).

I use Opus for the plan because the plan decides which files change and how they get checked, so it's worth the strongest model. Opus 5.5 is currently first on the leaderboard.

Grok 4.7 writes the code. To be honest it's average, a step behind the top models, but it can produce a first version from a written plan, and the quota was free.

Locally I use Codex on my own ChatGPT subscription. Code from the cloud often gets interaction details or copy slightly different from what I had in mind, and fixing that locally with Codex is faster than describing it again for the cloud.

Mobile is on me. Cloud Agents run in Linux VMs and can open a browser to check desktop (Electron) and Web, but the iOS simulator only runs on macOS.

## A Task's Journey Through Loop

### 1. Create the task, review the plan

When I create a task I write down the expected result, which platforms change and which don't, and paste the Jira link if there is one. After I click "Start plan", the Cloud Agent starts on Opus in plan mode and only writes a plan.

The full plan shows up in Loop. I check the scope and how it will be verified, and if it looks right I click "Approve and run". I don't need to open the Cursor website.

### 2. Cloud implementation

After approval, the same Agent switches to Grok 4.7, writes the code, runs the tests and checks desktop and Web. Loop shows what it's doing as it goes.

This is built on the [Cloud Agents API v1](https://cursor.com/docs/cloud-agent/api/endpoints) that Cursor shipped in late April: an Agent persists, each new prompt is a fresh run, and progress streams live over SSE. So each feature uses one Cloud Agent from start to finish, and the plan, the implementation and later review fixes are all runs on that Agent. The context is kept, and I don't have to copy the plan anywhere.

### 3. Local review

When the cloud is done, the task moves back to "Needs me". I click "Start local review" and Loop pulls the code into the task's own worktree, with the terminal already in that directory, so I can start the project and look.

The page lists the checks the cloud couldn't do and that need my confirmation:

![Local review: what the cloud can't verify is left for local](https://cdn.yikzero.com/markdown/images/loop-local-review-20261101.png)

I run it on iOS and Android and check the placement, copy and behavior against the requirement. If something is wrong, I ask Codex to fix it in the chat panel next to it.

### 4. Hand back to the cloud

When it passes, I hand it back. I tick only the files I want to commit and add a short note on what I tested and on which devices. The note goes to the cloud with the commit, so the Agent can read it when it handles reviews later.

![Handing back to the cloud: check the files, attach verification notes](https://cdn.yikzero.com/markdown/images/loop-return-20261101.png)

### 5. The cloud watches the PR

After the handoff, the Cloud Agent keeps following the PR. It fixes CI failures and responds to review comments. Same-repo PRs use Cursor's native PR subscription. Cross-fork PRs don't support it, so Loop reads the GitHub check status itself and sends failures back to the original Agent.

### 6. Requirement questions come back to me

Some review comments change the scope. Say the task only covers mobile and someone writes "let's do desktop too". In that case Loop has the Agent stop and asks me:

![Requirement-related review feedback thrown back to me as a question](https://cdn.yikzero.com/markdown/images/loop-decision-20261101.png)

If I decide to expand the scope, the plan is updated and the task goes around again. Any code change sends it back to step 3 for another local review.

### 7. Merge

Once CI passes, reviews are resolved and I've checked the latest commit, I click "Merge" in Loop.

## A Few Handoff Rules

The handoffs are where things go wrong, so Loop follows a few rules:

**Status lives on the board.** With three or four features open, the board shows which one is running in the cloud, which plan is waiting for me and which needs testing. Before Loop, I'd open GitHub and find a PR that had been waiting on me for half a day.

**Only one side changes the code at a time.** The cloud edits while the task is in the cloud, Codex and I edit once it's local, and after I hand it back it's the cloud's turn again.

**A review belongs to a specific commit.** After I've tested locally, the cloud may push another commit for a review comment, and then the code about to be merged isn't what I tested. So a new cloud commit cancels my earlier review, and only the commit I checked can be merged.

**The Agent's report isn't a review.** When the Agent says "all tests pass", I still check myself, and a check that didn't run doesn't count as passed.

## Next: iOS and Android

Mobile testing is still where I spend the most time by hand, so I plan to give the Agent a Mac: either a Mac mini left running at home, or a rented cloud Mac used when needed.

Either way, after writing the code the Agent would run the checklist on the Mac and send screenshots back to Loop, and I'd look at those instead of tapping through every screen myself.

For now it's only a plan. I'll write about it once it's set up.

This would mostly catch bugs, though. A test can tell whether a button is hidden, but whether the change is what users want still needs a person.

## Final Thoughts

These days my part of a feature is mostly reviewing the plan, testing locally, making product calls and merging. The rest goes to the Cloud Agent and Codex.

Whether the $900 pays off depends on how much time this saves me over the year. If I buy a Mac mini as well, it has even more to earn back (lol).