In 2026 the phrase “AI software engineer” stopped being a demo and became a job description. You hand an agent a ticket — a bug, a feature, a migration — and it disappears into a cloud machine, reads the codebase, writes the change, runs the tests, and comes back with a pull request. Cognition’s Devin named the category; a crowd of well-funded rivals now fills it, and some of the biggest names in software — OpenAI, Google, Anysphere — are shipping their own.
The pitch is nearly identical across all of them, which makes the real question easy to miss. Almost every serious agent can now open a PR. What actually separates them is everything around the agent: where it runs, what can wake it up, whether you can steer it from chat, whether it remembers how your team works, and whether you are locked to one vendor’s agent and model or free to bring your own. Here is how the leading autonomous AI software engineers stack up — and why the finished runtime beats even the cleverest agent on a bare wire.
The autonomous engineers
OpenAI Codex is the most surface-rich of the bunch. It runs coding tasks in isolated cloud sandboxes, executes multiple tasks in parallel, and proposes changes you can turn into pull requests, and you can reach it from ChatGPT, a CLI, an IDE extension, GitHub, and a Slack integration (Codex docs). It even ships Automations and a non-interactive mode for scheduled and background runs. Codex is included with every ChatGPT plan — Free, Plus at $20/month, Pro from $100/month — and since April 2026 meters overages as API-aligned credits (Codex pricing). The catch is the walled garden: Codex runs OpenAI models, on OpenAI’s terms, inside OpenAI’s surfaces. (Full disclosure — the Nori CLI is itself a fork of Codex; the underlying agent is excellent. The question is what you wrap around it.)
Google Jules is the clean async option. You point it at a GitHub repo, write a prompt, and Jules clones the repo into a cloud VM, plans with Gemini, and opens a pull request (Jules). It added a CLI (“Jules Tools”) and a public API in 2026, which is how you wire it into CI or a Slack ChatOps flow — there is no first-party Slack app. Jules is bundled into Google AI plans: a free tier at 15 tasks a day, Google AI Pro at $19.99/month for 100 daily tasks, and higher limits on Ultra (Jules usage limits). It is GitHub-native and Gemini-only — elegant if that is your stack, constraining if it is not.
Cursor Cloud Agents bring the editor’s agent to the cloud. Each agent gets an isolated VM with a full terminal and browser, onboards itself to the repo, and returns merge-ready PRs; Anysphere says agent-created PRs are now more than 30% of what merges internally (Cursor blog). You reach them from the web, an iOS app, Slack, GitHub, and Linear, and Cursor Automations run them on schedules or webhooks (Cursor Cloud). Individual plans run Pro at $20/month up to Ultra at $200/month, plus usage-based compute (Cursor pricing). Strong if your team already lives in Cursor; the cloud agents are an extension of that world, not a neutral home for any agent.
Factory takes the enterprise swing. Its “Droids” are autonomous agents that operate across the whole SDLC — triage, code, review, release — and run in the terminal, in Factory-managed cloud “Droid Computers,” or non-interactively via Droid Exec for CI/CD (Factory docs). It integrates with Slack, Linear, and GitHub and offers SaaS, hybrid, on-prem, and air-gapped deployment. Pricing is Pro at $20/month, Plus at $100/month, Max at $200/month, and custom Business and Enterprise tiers (Factory pricing). It is heavyweight and governance-forward — excellent for a large org, more platform than most teams need on day one.
OpenHands (All Hands AI) is the open-source anchor. It is an MIT-licensed autonomous agent you can self-host, plus a hosted cloud that runs agents in isolated sandboxes and opens reviewable PRs, triggerable from GitHub, Slack, PagerDuty, a CLI, and an SDK (OpenHands). Self-hosting is free; OpenHands Cloud has a free individual tier and a $20/month Pro subscription that bills LLM usage at cost with no markup (OpenHands pricing). It is model-agnostic and data-friendly — but self-hosting means you supply and operate the runtime around it yourself.
And the space keeps widening. A fresh wave of 2026 entrants pushes the same idea further: Replicas runs background agents from Slack, Linear, and GitHub that deliver production-ready PRs; Syntropy targets long-horizon, spec-driven tasks; and open-source Broccoli turns Linear tickets into PRs on cloud infrastructure you own. The agents are multiplying. The runtime question only gets louder.
How they compare
| Platform | Autonomous cloud runs (task → PR) |
Unattended triggers (cron / webhook) |
Chat-native control | Durable org context | Pricing model |
|---|---|---|---|---|---|
| OpenAI Codex | ✓ | ✓ | ✓ Slack | partial | ChatGPT plans, $0–$200+/mo |
| Google Jules | ✓ | partial | via API | partial | Google AI plans, Free–Ultra |
| Cursor Cloud Agents | ✓ | ✓ | ✓ Slack | partial | $20–$200/mo + usage |
| Factory | ✓ | ✓ | ✓ Slack | partial | $20–$200/mo + custom |
| OpenHands | ✓ | ✓ | ✓ Slack | partial | OSS free; $20/mo + usage |
| Nori Sessions | ✓ | ✓ | ✓ Slack + Discord | ✓ | Flat $50 / runtime / mo |
Publicly reported capabilities and pricing as of July 2026. See sources below.
How to choose an autonomous AI software engineer
Six criteria cut through the near-identical marketing faster than any feature grid:
- Whose agent and model you run. Codex means OpenAI models, Jules means Gemini, Cursor and Factory mean their own agents. If you want to run the best agent for each job — or swap as the frontier moves — you want a runtime that is agent-agnostic, not a single-vendor box.
- What can wake it up. A ticket assignment is table stakes. Real leverage comes from cron sweeps and webhooks that start work with no human present — the overnight dependency bump, the alert-driven fix.
- Where you steer it. Course-corrections should land where your team already talks. Deep Slack or Discord control beats another dashboard and another login.
- What it remembers. An agent that relearns your conventions every run is a liability. Durable org context — instructions, memory, tools — is what makes it show up already knowing the codebase.
- The human escape hatch. Agents do most of the work; humans still need a real terminal and editor on the actual machine when something goes sideways.
- Pricing you can forecast. Bundled subscriptions, credit pools, and metered compute are fine for bursty use but hard to budget for a fleet that runs every night. A flat line is easy to defend.
Every product in the table clears the first bar — they open PRs. The split is everything above that line, and it points at a layer none of them fully own.
An agent is not a runtime
Two years ago, “takes a task and returns a PR” was the whole magic trick. In 2026 it is a commodity — Codex, Jules, Cursor, Factory, and OpenHands all do it well. That is real progress, and it is also where most of them stop.
Because opening a PR is only the last inch. Before an autonomous agent ships one from a cloud machine, something has to stand up the machine, load the agent, connect GitHub and Slack, route the model, load your org’s instructions, and wire notifications back — then hand a human a way to jump in when the agent gets stuck. Each product gives you a strong agent bolted to its own thin runtime, and usually its own model too. Codex gives you OpenAI-everything. Jules gives you Gemini and GitHub. Cursor gives you the Cursor world. Factory gives you an enterprise platform. OpenHands gives you the code and leaves the operating to you. None of them hands you the whole runtime — agent-agnostic, triggered, chat-native on Slack and Discord, loaded with org context, with a real workspace — as one product you can give a team on Monday.
Why Nori Sessions wins
Nori Sessions is that runtime. Every session is an ephemeral cloud machine that arrives with the entire stack already standing — and it runs the autonomous agent you choose:
- Bring any agent. Run Codex, Claude Code, Gemini, Cursor Agent, or your own harness inside a session. You are never locked to one vendor’s agent or one lab’s model — pick the best for the job.
- Triggers are first-class. Cron and webhook triggers launch sessions with no human attached. This very article was researched, written, and opened as a pull request by a scheduled Nori Session.
- Chat-native on Slack and Discord. Drive sessions from the tools your team already lives in and get results back in the thread — not buried in a fourth dashboard.
- Durable org context. Skillsets load every fresh machine with your org’s instructions, memory, and tools, so agents show up already knowing how you work — no per-repo config to keep in sync.
- A real workspace on demand. A full terminal and editor are one click away whenever a human wants to inspect or take over.
And instead of bundled-plan math, credit pools, or metered compute per lab, Nori Sessions is a flat $50 per runtime per month, with a Premium tier that adds hands-on org setup and dedicated support. Predictable enough to budget for a fleet. Simple enough to explain in one sentence.
The bottom line
If you want a single autonomous engineer inside ChatGPT, Codex is the most surface-rich pick. If you live in GitHub and Gemini, Jules is the clean async path. If your team is already in Cursor, its cloud agents extend that world. If you are an enterprise standardizing the SDLC, Factory is built for it. If you want open-source and model choice, OpenHands is the anchor. But if what you actually want is the best agent for each job doing real work in ephemeral cloud machines — on a schedule, from chat, with your context loaded and a human escape hatch one click away — you do not want a clever agent stapled to a single-vendor runtime. You want the finished runtime, and the freedom to run any agent inside it. That is Nori Sessions, and it is the layer this entire category is racing to assemble. We already ship it.
Spin up your first Nori Session and put your agents to work.
Frequently asked questions
What is an autonomous AI software engineer?
An autonomous AI software engineer is a coding agent that takes a task — a ticket, an issue, a plain-English prompt — and works it end to end in a cloud environment: it clones the repo, plans the change, writes and tests the code, and opens a pull request for review, all without a human driving each step. Devin, OpenAI Codex, Google Jules, Cursor Cloud Agents, Factory, and OpenHands are all versions of this idea. The differences are less about whether they can open a PR and more about what runs them, what triggers them, and how much of your team’s context they carry.
Which autonomous coding agent is best in 2026?
There is no single winner, because these products optimize for different things. OpenAI Codex is the most multi-surface and is bundled into ChatGPT plans. Google Jules is the most GitHub-native async option. Cursor Cloud Agents fit teams already in Cursor. Factory targets the enterprise SDLC. OpenHands is the open-source pick. If what you want is not one agent but a place to run whichever agent you choose — with triggers, chat control, org context, and a real workspace — that is the runtime layer, and Nori Sessions is built for it.
How much do autonomous AI coding agents cost?
Most are priced through a subscription plus metered usage. OpenAI Codex is included in ChatGPT plans from Free through Plus at $20/month and Pro from $100/month, with credit-based overages. Google Jules is bundled into Google AI plans, with a free tier and Google AI Pro at $19.99/month. Cursor’s cloud agents come with plans from $20/month (Pro) to $200/month (Ultra) plus usage. Factory runs $20/month (Pro) to $200/month (Max) plus custom enterprise. OpenHands is free and open-source to self-host, with a $20/month cloud Pro tier billing LLM usage at cost. Nori Sessions is a flat $50 per runtime per month.
Can I run these agents on a schedule or from Slack?
Some can. OpenAI Codex has Automations and a Slack integration, Cursor offers scheduled and webhook-driven Automations plus Slack control, and OpenHands supports scheduling and triggers from GitHub, Slack, and PagerDuty. Google Jules leans on GitHub issue labels and its API rather than a native Slack app. Nori Sessions treats cron and webhook triggers as a first-class primitive and is chat-native across both Slack and Discord, so any agent you run inside a session gets those controls for free.
What is the difference between an autonomous agent and an agent runtime?
An autonomous agent is the worker that reads a task and proposes code. An agent runtime is the machine, triggers, integrations, org context, and human workspace it runs inside. Most autonomous SWE products couple a strong agent to their own thin runtime, so you take their agent and their model or nothing. A runtime like Nori Sessions inverts that: it runs whichever agent you choose — Codex, Claude Code, Gemini — and supplies the triggers, chat control, durable context, and terminal-plus-editor around it.
Are there open-source autonomous AI software engineers?
Yes. OpenHands by All Hands AI is MIT-licensed and can be self-hosted in your own environment, with an optional hosted cloud. Newer open entrants like Broccoli turn tickets into PRs on infrastructure you control. Open-source agents give you data control and model choice, but you still supply the runtime around them — scheduling, chat, credentials, and a workspace — which is exactly what Nori Sessions provides.
Sources
- OpenAI Codex overview — OpenAI
- Codex pricing — OpenAI
- Jules — Google
- Jules usage limits — Google
- Cursor Cloud Agents — Anysphere
- Cursor pricing — Anysphere
- Agents that use a computer — Cursor blog
- Factory documentation — Factory
- Factory pricing — Factory
- OpenHands — All Hands AI
- OpenHands pricing — All Hands AI
- Devin — Cognition
- Replicas — background coding agents
- Broccoli — open-source ticket-to-PR agent
Related guides
- The Best Unattended AI Coding Agents in 2026 — the trigger-driven side of the same shift: agents that start without you.
- Top AI Coding Agent Runtimes & Sandboxes in 2026 — the isolation layer beneath every autonomous run: Firecracker, gVisor, and millisecond boots.
- AI enablement requires managed agent runtimes — why the runtime, not the agent, is the layer that matters.