Copilot coding agent vs Jules vs Codex (2026)
Copilot coding agent vs Jules vs Codex: how the GitHub, Google, and OpenAI background agents compare on triggers, models, pricing, and lock-in.
GitHub, Google, and OpenAI each ship a background coding agent now: you hand it a task, it works in a cloud environment, and it comes back with a pull request. The three products rhyme, but the details decide which one fits your team. The short answer: Copilot is the only one with multi-vendor model choice, Jules is Gemini-only and shaped for individual accounts, Codex rides your ChatGPT plan, and none of the three takes your own API key. The longer answer is how Copilot coding agent vs Jules vs Codex shakes out on triggers, execution environments, models, pricing, and the review loop.
Product details checked August 2026. Vendors change; check their docs for current specifics.
One naming note first: GitHub's documentation now calls the product "Copilot cloud agent." Most people still search for and say "coding agent," so we use both below; they're the same feature.
GitHub Copilot coding agent
The Copilot agent lives where your code already is. You start a task by assigning an issue to Copilot on github.com, mentioning @copilot in a pull request comment, or delegating from the agents panel, VS Code, or GitHub Mobile. It runs in what GitHub describes as an ephemeral development environment powered by GitHub Actions, where it can explore the code, make changes, and run tests and linters. It works on a branch, opens a pull request, and iterates when you leave it review comments. It only works with repositories hosted on GitHub.
On models, GitHub is the odd one out among the three, in a good way: there's a model picker that includes models from Anthropic, OpenAI, Google, xAI, and Microsoft. The default is an "Auto" mode that chooses for you, and the picker is only available from the main entry points. You choose from GitHub's catalog on GitHub's terms; there's no bring-your-own-key.
Pricing runs through Copilot plans: the agent is included on every paid tier, from Pro at $10 per month through Pro+ at $39, Max at $100, Business at $19 per seat, and Enterprise at $39 per seat. Usage draws down two meters at once: GitHub Actions minutes and AI credits (GitHub's token-metered currency). The Free plan doesn't include the cloud agent. We've also put Copilot's agent head to head with Devin, if that's the comparison you're actually shopping.
Google Jules
Jules is Google Labs' asynchronous coding agent. The primary interface is the web app, where you describe a task against a connected GitHub repo. You can also add a jules label to a GitHub issue to start a task from the tracker, script it with the Jules Tools CLI, or call the Jules API. Each task runs in a VM that clones your code and installs dependencies.
The review loop is the most cautious of the three. Jules generates a plan first, and you can review and approve it before any code changes are made. Then you get the diff, and the result is published back to GitHub as a branch or pull request. An optional AGENTS.md file in the repo gives it standing context.
Models are Gemini, full stop. Per the usage limits page, the free tier runs Gemini 2.5 Pro with 15 tasks per day and 3 concurrent; the paid tiers get access to the latest model (Gemini 3 Pro at the time of checking) with 100 tasks per day and 15 concurrent on Pro, 300 and 60 on Ultra. The paid tiers are sold through Google's consumer AI subscriptions, and the docs note they're available only for individual Gmail accounts, which is an awkward fit for a company rollout.
OpenAI Codex
Codex is OpenAI's agent product (the name once belonged to a 2021 model; today it means the coding agent). It spans a CLI, an IDE extension, and the piece relevant here: Codex cloud, which runs tasks in isolated, OpenAI-managed environments preloaded with your repository. You can start work from the web app, from GitHub pull requests and issues, or from Linear and Slack, which makes Codex the only one of the three with a tracker trigger outside its own platform. There's also an automatic code review mode for your PRs.
The loop: Codex works in its sandbox, hands you a summary and a diff, takes follow-up requests, and opens a pull request when you're happy. Repo support is GitHub.
Models are OpenAI's. The current recommended lineup is the GPT-5.6 family, and when you sign in with ChatGPT you choose among OpenAI's models only. (The open-source CLI can be pointed at other providers with an API key, but the cloud product is OpenAI end to end.)
Pricing rides on ChatGPT plans. Codex is included across the plan lineup; Plus at $20 per month covers cloud tasks and code review, Pro raises the limits substantially, and Business and Enterprise add workspace controls. When you hit a plan's usage limit you can buy additional credits to keep working.
Copilot coding agent vs Jules vs Codex at a glance
| Copilot coding agent | Jules | Codex | |
|---|---|---|---|
| Vendor | GitHub (Microsoft) | OpenAI | |
| Trigger | Assign an issue, @copilot on a PR, agents panel, VS Code, mobile | Web app, jules label on a GitHub issue, CLI, API | Web app, GitHub PRs/issues, Linear, Slack |
| Where it runs | Ephemeral environment on GitHub Actions | A Google-managed VM | OpenAI-managed isolated environments |
| Repo support | GitHub only | GitHub | GitHub |
| Models | Picker across GitHub's multi-vendor catalog; no BYOK | Gemini only | OpenAI models only |
| Plan required | Any paid Copilot plan (from $10/mo); AI credits + Actions minutes | Free tier; higher limits via Google AI subscriptions (individual accounts) | ChatGPT plans; Plus ($20/mo) covers cloud tasks; credits for overage |
| Review loop | Branch, PR, iterate via @copilot comments | Plan approval before changes, then diff and PR | Summary + diff, follow-ups, then PR |
Platform gravity
Each of these agents is good, and each pulls you deeper into its vendor's stack, which is the business model working as intended. It still has consequences worth naming before you standardize on one.
The obvious one is model lock-in. Jules runs Gemini and Codex runs OpenAI models, regardless of who is ahead this quarter. Frontier models leapfrog each other every few months, and with a single-vendor agent you can't route a task to a better model when one ships; you wait for your vendor's next release. Copilot's multi-vendor picker softens this, but the catalog and its contents are GitHub's call, and model availability on all three platforms changes at the vendor's discretion. OpenAI's own changelog shows models being retired for ChatGPT-signed-in Codex users while remaining available on the API, a decision no user made.
Billing has its own gravity. None of the three lets you bring your own API key to the cloud agent. Usage is metered in platform currencies (AI credits, task quotas, plan tiers) rather than at provider token prices, so comparing the real cost of a task across them is guesswork, and your agent spend is bundled into a subscription whose price the platform sets.
The last is the stack itself. Copilot assumes GitHub; the deeper you go, the more Actions minutes and GitHub plans matter. Jules assumes a Google account and sells capacity through Google's consumer AI subscriptions. Codex is the front door to ChatGPT for engineering teams. Choosing an agent quietly becomes choosing an ecosystem, which is fine if you were staying anyway, and expensive if you weren't.
Where independent agents fit
The alternative is an agent that treats models as interchangeable parts. Independent background agents, Sinatra among them, let you pick the model per repo or per task and bring your own key, so you pay provider prices with no markup and switch models the day a better one ships. Sinatra's version of the loop is tracker-native: assign a Linear issue or label a GitHub issue, and a pull request comes back for review. We compared the wider field in our roundup of background coding agents, and our alternatives page covers the head-to-heads.
Common questions
Is "Copilot coding agent" the same as "Copilot cloud agent"?
Yes. GitHub's docs renamed the feature "Copilot cloud agent"; it's the same product that launched as the coding agent: assign work on GitHub, it runs on Actions, and it opens a pull request.
Can I bring my own API key to any of these?
Not to the cloud agents. Copilot, Jules, and Codex cloud all meter usage through their own plans. The one partial exception is the Codex CLI, which can run against an OpenAI API key at API prices (and can be pointed at other providers), but that's the local tool, not the cloud agent.
Which one works with GitLab or Bitbucket?
None of them, when we checked. GitHub's docs are explicit that the agent only works with GitHub-hosted repositories, and Jules and Codex cloud both document GitHub as the supported platform. If you're on GitLab, the practical option in this category is OpenHands, which we covered in a separate review.
Which should I pick if I just want tickets turned into PRs?
If your team lives on GitHub and already pays for Copilot, the coding agent is the shortest path. If your tickets live in Linear and you want to choose the model doing the work, that's the gap the platform agents leave open, and it's the one we built for.
If you want the ticket-to-PR loop with your own keys and your own model choices, you can start for free or read the docs to see how Sinatra runs it.