Copilot coding agent vs Jules vs Codex (2026)

· 8 min read · Updated · Sinatra

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 agentJulesCodex
VendorGitHub (Microsoft)GoogleOpenAI
TriggerAssign an issue, @copilot on a PR, agents tab, VS Code, mobile, CLI; Linear, Jira, Slack, TeamsWeb app, jules label on a GitHub issue, CLI, APIWeb app, @codex on GitHub PRs, Linear, @ChatGPT in Slack
Where it runsEphemeral development environment, powered by GitHub ActionsA Google-managed VMOpenAI-managed isolated environments
Repo supportGitHub onlyGitHubGitHub; GitLab in beta
ModelsPicker across GitHub's multi-vendor catalog; no BYOKGemini onlyOpenAI models only
Plan requiredAny paid Copilot plan (from $10/mo) or the free Student plan; AI credits + Actions minutesFree 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 loopBranch, PR, iterate via @copilot commentsPlan approval before changes, then diff and PRSummary + 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

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.