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.
On this page
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 October 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 tab, VS Code, GitHub Mobile, or the GitHub CLI, and it also takes work from Linear, Jira, Azure Boards, Slack, and Teams. It runs in an ephemeral development environment, powered by GitHub Actions and billed in Actions minutes, where it can explore the code, make changes, and run tests and linters. It works on a branch. Some entry points open a pull request automatically; from the others you ask for one in your prompt or create it from the session logs. It 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 picker is only available from the main entry points; where there isn't one, an "Auto" mode chooses for you. You choose from GitHub's catalog on GitHub's terms: Copilot's bring-your-own-key covers Chat, the CLI, and IDEs, not the cloud agent.
Pricing runs through Copilot plans: the agent is included on every paid tier (and on the free Student plan), 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. Jules's changelog made Gemini 3 Flash the base model on every tier in January 2026 and Gemini 3.1 Pro the default for Pro subscribers in March; the usage limits page still names older models, so trust the changelog. The limits on that page are current: 15 tasks per day and 3 concurrent on the free tier, 100 and 15 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. There is a fuller Jules review if it is on your shortlist.
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 a GitHub pull request comment, from Linear, or from Slack, where the bot now answers to @ChatGPT rather than @Codex. 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, plus GitLab in beta for merge-request reviews and GitLab-triggered tasks.
Models are OpenAI's. OpenAI's models page recommends GPT-6.1 Sol, lists GPT-6 Astra as its most capable model and GPT-6 Luna for focused tasks, and keeps the GPT-5.6 models available during the rollout, 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 in every plan, but cloud tasks start at Plus: $20 per month covers cloud tasks and code review, Pro raises the limits substantially, and Business and Enterprise add workspace controls. What each tier actually buys is a rate limit rather than a rate, which we unpacked in Codex cloud pricing, explained. On Plus and Pro, when you hit the usage limit you can buy 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 tab, VS Code, mobile, CLI; Linear, Jira, Slack, Teams | Web app, jules label on a GitHub issue, CLI, API | Web app, @codex on GitHub PRs, Linear, @ChatGPT in Slack |
| Where it runs | Ephemeral development environment, powered by GitHub Actions | A Google-managed VM | OpenAI-managed isolated environments |
| Repo support | GitHub only | GitHub | GitHub; GitLab in beta |
| Models | Picker across GitHub's multi-vendor catalog; no BYOK | Gemini only | OpenAI models only |
| Plan required | Any paid Copilot plan (from $10/mo) or the free Student plan; AI credits + Actions minutes | Free tier; higher limits via Google AI subscriptions (individual accounts) | ChatGPT plans; cloud tasks from Plus ($20/mo); credits past the limit on Plus and Pro |
| 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 pin the model per repo and bring your own key or subscription, so the model bill stays between you and your provider and you can switch models the day a better one ships. Sinatra's version of the loop is tracker-native: assign a Linear issue, label a GitHub issue or mention it in a Slack thread, 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
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.
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.
Codex, partly. OpenAI added GitLab in beta: Codex reviews GitLab merge requests and can run GitLab-triggered tasks. GitHub's docs are explicit that Copilot's agent only works with GitHub-hosted repositories, and Jules documents GitHub only. None of the three lists Bitbucket. If you're on GitLab and want something past a beta, look at OpenHands, which we covered in a separate review.
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.
Assign the issue. Come back to a PR.
Sinatra picks up work from Linear, GitHub and Slack and opens a draft pull request for your team to review. Bring your own Claude or Codex access; Sinatra never bills for model usage.