Your AI coding agent is stuck in a terminal you have to babysit. So we built GetPullRequest

The agents got good. Claude Code, Codex, Cursor and the rest can take a well-written ticket and produce a change you'd actually merge. What didn't change is everything around them. The agent lives in a terminal on your laptop. It stops to ask a question while you're in a meeting, and the question sits there for two hours. When it finishes, the PR waits until you're back at a desk.

We felt this every day, because we were building a product with four of these agents at once. GetPullRequest (GPR) is what we built to fix it, and we've built GPR with GPR since May. This post explains the gap we saw, where GPR fits, what it's bad at, and where we think this is going.

TL;DR: GPR runs the coding agent you already pay for, on the machine that already builds your project. Tasks come in from GitHub, GitLab, Jira or Slack, and a pull request comes back to your phone. It's free to start.

Two answers, both from the vendors

The industry has offered two answers to "my agent is stuck at my desk".

The first is to move the agent into the vendor's cloud. Devin, GitHub's Copilot coding agent, Codex cloud and Cursor's Cloud Agents all work this way. You hand over a ticket, a VM somewhere clones your repo, and a PR comes back. For a project that builds from a clean checkout in two minutes, that's great.

Ours doesn't. Our repo has a FastAPI backend, a Flutter app, a database and a Go daemon that all need to come up together. We tried hosted sandboxes first, with Daytona, and gave up for three reasons. Wiring all four pieces together inside a sandbox, and keeping them working as the code changed, was a project in itself. It cost money a small startup didn't want to spend while our own laptops sat idle half the day. And testing was slow: every check meant a checkout and a full build to recreate an environment that already existed, fully built, on the laptop in front of us. Hosted agents also usually mean another subscription, billed per task or at API prices, on top of the agent plans we already paid for.

The second answer is a remote for your own machine. Claude Code has Remote Control, and Codex now connects to the ChatGPT app. These keep the agent local, which we think is right. But each one is a remote for one vendor's agent, and it's built around a session you started yourself. Our work doesn't arrive that way. It arrives as a GitHub issue, a Jira ticket from someone in product, or a screenshot in Slack. It goes to whichever agent suits it, and it should end as a pull request, not a chat log.

"Work doesn't arrive as a chat session. It arrives as a GitHub issue, a Jira ticket from someone in product, or a screenshot in Slack."

The gap

Put those side by side and one combination is missing. Nothing ran the agent you already pay for, on the machine that already builds your project, fed by the tools where work actually gets asked for, and handed back a PR you could review from anywhere.

That's GetPullRequest. A small daemon runs on your machine. It takes tasks from the board in our phone app, from GitHub issues labelled gpr:agent, from Jira, or from an @gpr mention in Slack. For each task it creates a git worktree, starts your agent, and runs plan, implement and verify. Then it opens a PR. Your phone shows the session live, buzzes when the agent has a question, and lets you read the diff and merge.

Two decisions that shaped everything

We don't ship our own agent. Developers already pay for one or two. Asking them to buy another before they can try GPR is friction, and it's paying twice for the same thing. We didn't know how to support every agent without writing an integration per agent. Then we watched Ben Brandt from Zed and people from JetBrains explain the Agent Client Protocol. ACP solves the editors-times-agents problem for IDEs, and we realised a phone could be just another client. GPR now runs Cursor, Claude Code, Codex, Kiro, OpenCode, Qwen, Cline and Copilot through it. The ACP post goes deeper.

The cloud only enriches. Everything core works with nothing connected: the board, the queue, the agent run, the diff and the merge check. The diff and merge check come from git on your machine, because that's where the agent's work actually is, including changes GitHub has never seen. GitHub, GitLab, Jira and Slack plug in as adapters behind ports, and they only add to what's there. When Atlassian removed an old search endpoint in September and our Jira calls started returning 410 Gone, agents kept working. Only new tickets stopped syncing. The fix was ticket PET2-4, which GPR picked up from Jira and turned into PR #500, with tests passing on the first attempt.

Built with itself

By the time of writing, the GPR code had about 450 commits. 370 of them are co-authored by GPR. Our branch list is full of gpr/task-tsk_… names, which is what GPR calls the branches it creates. The conversation minimap in the task screen was PR #318, opened by GPR against its own repo. When worktree badges started leaking into unrelated chat sessions, the fix was PR #502, and its squash shows four agent iterations before the change was right.

Building it this way also meant we hit every rough edge first. In August one machine had 52 cursor-agent processes running after six and a half minutes, about 300 MB each, because they raced on a config file and ignored SIGTERM. Windows sockets went half-open and the daemon never noticed. Agents finished turns with no commits and GPR marked them done. Each of those is fixed now, and most of the fixes were written by agents through GPR. The stories are spread across the posts in this series.

What it's not good at

A machine has to be on. If your laptop sleeps, its tasks wait until it wakes, so people who want agents working overnight end up pairing a desktop. The Android app is live, and iOS isn't in the App Store yet. The phone is good for answering a question, approving a command, reading a small diff and merging. It's not good for reviewing a big architectural change, and we don't pretend otherwise. If you only use one agent and want to poke at one session, Claude Code Remote Control or the ChatGPT app is simpler. But still its not smooth with other tools that you are operating with. You have to deal with lot of rough edges which GPR is designed to handle.

Where this is going

Our bet is that most engineering work will look like what our team already does. Engineers spend less time typing code and more time deciding what should be built, writing tasks an agent can finish, and reviewing what comes back. The code still gets built and tested where it always was, on machines the team controls. The agents become interchangeable, and you pick one per task the way you'd pick a library. Work arrives from wherever people already talk about it.

The useful product isn't another agent. It's the layer between where work is asked for and where it's done.

In that world, the useful product isn't another agent. It's the layer between where work is asked for and where it's done, and the thing in your pocket that lets you keep up with it. That's what we're building GetPullRequest into.

What's next on this blog

Over the next two weeks we'll publish the rest of this series. Each post takes one tool people already use and is honest about where it beats us:

• Claude Code Remote Control is great. It's also not enough
• Agent Client Protocol (ACP) is the most important AI coding standard nobody's talking about
• Cursor background agents charge you twice for compute you already own
• Codex CLI remote control: stop babysitting the terminal and let it ship PRs while you're out
• Slack AI agents should open pull requests, not summarize threads
• A Jira AI agent fixed our Jira integration
• Devin AI alternatives: why pay for another AI engineer?

Try it

GPR is free for projects, sessions, and the GitHub and Slack connections. You pay only for more workspaces or more tasks running at once. Get the app on Google Play, (iOS app coming soon) then on a Mac, Linux or Windows machine with one coding agent installed:

curl -fsSL https://getpullrequest.com/install | bash
cd ~/code/your-repo
gpr setup        # scan the QR code with the app
gpr discover     # lists which agents are ready

Start with a small, boring task, something you'd normally put off, and see what's waiting for you when you get back.