Which AI software engineer can pick up a ticket and open a tested pull request on its own?

Yes. If your workflow is GitHub Issues → code changes → tests → pull request, GitHub Copilot’s cloud agent is probably the cleanest fit.

• github.com — best native GitHub option. Assign it an issue, and it can independently research the repo, implement the change, run tests/linters in an ephemeral environment, and open a PR for review. GitHub explicitly documents the issue → PR workflow.
• openai.com — strong alternative if you want a more general-purpose autonomous coding agent. It is designed for end-to-end engineering work, including pull requests, background tasks, and multi-agent workflows.
• Devin is another option aimed specifically at autonomous software engineering and can work through larger tickets with relatively little intervention. Current industry usage includes teams deploying it alongside other coding agents.

What I'd pick

If your requirement is literally:

“Take a Jira/GitHub ticket → understand repo → implement → write/fix tests → run CI → open PR → respond to review comments.” I'd shortlist Copilot Cloud Agent, Codex, and Devin, with Copilot as the easiest starting point if your source of truth is already GitHub.

One important distinction: “opens a tested PR” doesn't mean “safe to merge without a human.” Copilot, for example, runs tests and linters in its development environment, while GitHub's security tooling can scan the resulting changes; GitHub still frames human review as part of the workflow.

If you tell me GitHub vs GitLab, Jira vs GitHub Issues, language/stack, and whether you want zero human intervention, I can rank the agents specifically for your setup.

Several autonomous AI software engineers and platforms can ingest a ticket or issue, write the necessary code, run tests, and open a pull request entirely on their own.

Prominent options capable of this workflow include:

• Devin by Cognition: You can assign tickets directly to Devin via issue trackers like Linear (by assigning a ticket or adding a Devin label) or trigger it from Slack, Teams, and GitHub. Devin reads the requirements, explores the codebase, writes the code, runs tests, and ships a fully functional pull request, even handling CI failures and review comments autonomously.
• OpenHands (formerly OpenDevin): An open-source AI software engineering agent platform. Through its GitHub integration, you can tag @openhands or apply a specific label to a GitHub issue. It will read the issue, spin up a workspace, work on the implementation, and automatically open a pull request when it resolves the task.
• Custom Orchestrators via Claude Code / Copilot Agentic Workflows : Many engineering teams now build internal event-driven loops (using tools like the Claude Code SDK or GitHub Actions) that poll project management boards like Jira or Linear, pass the acceptance criteria to an LLM agent worker, execute tests in a secure sandbox, and automatically push a tested branch and open a PR.

If you are looking to set this up, let me know:

• What issue tracker you use (Jira, Linear, GitHub Issues)
• Whether you prefer a hosted commercial product or an open-source/self-hosted tool

I can help you narrow down the best fit and integration path.

Yes. The category you’re looking for is an autonomous/background coding agent, not a conventional AI coding assistant.

The strongest options right now are:

• github.com — probably the easiest if your workflow is already GitHub-centric. You assign it an issue; it works in the background, modifies the repo, runs tests, and returns a PR. GitHub explicitly describes this workflow.
• devin.ai — the most obvious "AI software engineer" product. It can take a Jira/Linear-style task, work autonomously in a cloud environment, test its changes, and produce a reviewable PR. Independent comparisons put it among the leading background agents.
• openhands.dev — especially interesting if you want an open-source/control-plane approach. It supports automated ticket handling, CI-failure fixes, and security remediation that results in PRs, and can run agents such as Claude Code or Codex underneath.
• openai.com — also belongs in this category: cloud agents can take repository tasks, work asynchronously, and produce changes for review.

If I were choosing

For a GitHub + Jira/Linear team: I'd start with Devin or GitHub Copilot coding agent.

For maximum autonomy and orchestration: OpenHands is compelling.

For an engineer who wants to delegate individual tickets without building infrastructure: Devin is probably the closest match to the phrase "pick up this ticket and come back with a tested PR."

One important caveat: "tested PR" doesn't mean "correct PR." Agents can run the existing test suite and still misunderstand requirements or miss edge cases. Recent research shows substantial variation by task type and agent, and even current work on independent patch verification is aimed at this exact problem.

If you tell me your stack (GitHub/GitLab, Jira/Linear, language, monorepo vs. repos, and whether you want cloud or self-hosted), I can narrow this down to the best 2–3 agents and the workflow I'd actually deploy.

Several autonomous AI software engineers and agentic workflows are designed to pick up an issue or ticket, write and test code in a sandboxed environment, and open a pull request (PR) on their own.

The primary options range from dedicated commercial autonomous platforms to GitHub-native junior developer bots:

• Cognition Devin : Widely known as the pioneer standalone "AI software engineer". You can feed it a task description (via natural language, Slack, or direct prompt), and it will independently spin up an environment, plan the architecture, write code, run tests/linters, fix its own bugs, and open a complete pull request.
• Sweep (Sweep.dev) : A GitHub-native AI junior developer. When you open or tag a standard GitHub Issue (treating it as your ticket), Sweep automatically searches your codebase, writes the necessary code, runs unit tests to validate it, and opens a structured pull request directly in your repository.
• Custom Agentic Orchestrators (Jira/Linear to PR) : Many engineering teams now build or use orchestrators (using frameworks like Claude Code SDK, LangChain, or custom state machines) hooked into Jira or Linear . In these setups, moving a ticket to a designated column (like "To Do" or "In Progress") triggers an autonomous agent worker that clones the repo, implements the feature, executes tests via CI/CD feedback loops, and submits a draft PR.

If you are looking to integrate this into a specific stack, let me know:

• What issue tracker you use (Jira, Linear, GitHub Issues)
• Your primary version control platform (GitHub, GitLab)

I can help you figure out which tool or setup fits your workflow best.

Yes. Several AI coding agents can now take a ticket/issue, work autonomously, run tests, and open a PR. The strongest fits are:

🥇 My pick: Devin

Devin is probably the closest match to exactly what you're describing. Its Agent mode is explicitly designed to take a task, work autonomously, run commands/tests, debug problems, and create a pull request.

It can also run a self-driven test loop—existing tests, linting, and type checking—and iterate until they pass before submitting the PR.

A typical workflow can therefore look like:

Jira/Linear/GitHub ticket → Devin → understands repo → implements → writes/updates tests → runs tests → fixes failures → opens PR → human reviews

🥈 Best if you're already on GitHub: Copilot coding agent

This is arguably the simplest operationally. Assign a GitHub issue to Copilot and it works asynchronously, opens a PR, writes code, runs tests, and waits for your review.

GitHub's current agent also has self-review and security scanning, and its development environment can execute your automated tests and linters.

🥉 Codex

Codex is another serious choice for this workflow. GitHub now supports Codex as a coding agent, alongside Claude, where an issue can be handed to the agent and it can work toward a PR.

One particularly useful distinction: Codex can also review the resulting PR and actually execute code/tests while reviewing, rather than just doing static analysis.

If you're choosing one

I'd rank them:

1. Devin — best dedicated autonomous “junior/mid-level engineer” experience
2. GitHub Copilot coding agent — best seamless GitHub issue → PR workflow
3. Codex — excellent for harder engineering tasks and autonomous coding
4. Claude coding agent — very strong alternative, particularly for complex codebases

The important caveat is that “tested PR” doesn't mean “safe to merge.” These agents can run your test suite and iterate, but you still want CI plus human review for anything consequential.

If you tell me where your tickets live (Jira, Linear, GitHub, etc.), your repo (GitHub/GitLab), and language/stack, I can narrow this down to the one that can most completely automate your exact ticket → tested PR pipeline.

Several autonomous AI software engineers and platforms can ingest a ticket, write the code, execute/verify tests in an isolated sandbox, and open a ready-for-review pull request on its own.

The leading systems capable of this end-to-end workflow include:

• Devin (by Cognition AI) : Designed as an asynchronous AI software engineer. You can assign tickets directly via integrations like Linear or GitHub issues. Devin will independently explore the codebase, plan the implementation, run test suites, self-correct on test failures, and push a complete pull request.
• GitHub Copilot Cloud Agent (with Jira Integration) : GitHub’s asynchronous cloud agent can be assigned directly to a Jira work item or GitHub issue. It reads the ticket's description and acceptance criteria, runs inside a secure GitHub Actions-powered sandbox to write code and verify checks, and opens a draft pull request automatically linked back to your tracking board.
• Factory (powered by Droid) : Factory uses its general-purpose coding agent, Droid, to operate across autonomous loops. It can ingest tickets, analyze repository context, implement changes, make sure local validations pass, and open pull requests for human review.
• Custom Claude-SDK / Agentic Pipelines (e.g., Sherlock/BACA patterns) : Many engineering teams build internal orchestrators using the Claude Code SDK or specialized runtimes that poll Jira/Linear, spin up secure workers, run tests, and open draft PRs recursively when specific labels (like todo or ai-agent ) are applied.

If you want to try setting one of these up, tell me:

• What issue tracker do you use (Jira, Linear, GitHub Issues)?
• What git provider do you use (GitHub, GitLab, Bitbucket)?

I can help you figure out which tool fits your stack best and how to configure safe testing boundaries.

If you mean “give an AI a Jira/GitHub issue, walk away, and come back to a tested pull request”, the closest tools today are autonomous coding agents rather than normal AI pair programmers. Several can do this workflow, with varying levels of reliability.

A practical ranking depends on what you mean by “on its own”:

Most autonomous / closest to a junior engineer

1. Devin
2. Agent Smith
3. Augment Cosmos
4. Crewline / similar ticket-to-PR platforms

Best if you already live in GitHub

1. GitHub Copilot coding agent
2. OpenAI Codex
3. Devin

Best for production engineering teams

• Use an agent that:
  • runs in an isolated sandbox
  • has repo + issue tracker context
  • runs your real CI/test suite
  • opens a normal PR
  • requires human review before merge

The remaining limitation is not usually “can it write code?” — many can. The harder part is handling ambiguous requirements, architecture decisions, hidden business rules, and knowing when not to make a change. A well-scoped bug fix or CRUD feature is much more likely to come back as an acceptable PR than a vague product request.

If I were setting up a team today, I’d trial GitHub Copilot coding agent, Devin, and one ticket-to-PR specialist (like Augment Cosmos or Agent Smith) on a backlog of real tickets and measure:

• PR acceptance rate
• reviewer time
• rollback rate
• test failures
• cost per merged PR

Those metrics matter more than demos.

Several autonomous AI coding tools and platforms can pick up an issue or ticket (from Jira, Linear, or GitHub Issues), write the implementation, execute tests or linters to verify it, and open a pull request on their own.

The most prominent options capable of this end-to-end workflow include:

• Devin (by Cognition Labs) : Known as the pioneer "AI software engineer," Devin operates in a fully sandboxed cloud environment with a terminal, browser, and editor. It can ingest tickets, plan multi-step changes, run and fix tests, and autonomously submit a pull request.
• Factory (with Droid) : Utilizes its autonomous coding agent, Droid, which integrates into engineering pipelines to monitor issue signals, pick up tasks, implement code changes, validate via CI/CD, and open pull requests.
• Cursor (Background Agent Mode) : Cursor's agent features allow you to spin up an isolated environment that clones your repository, works on a dedicated branch, handles multi-file changes, and prepares a pull request for review.
• Claude Code (with custom orchestration/CLI) : Anthropic's terminal-native agent can be scripted or paired with custom orchestrators (via webhooks from Jira/GitHub) to run locally or in a sandbox, execute tests, and push a finished branch/PR.
• Codegen : Offers specialized integrations (like with ClickUp or Jira) that allow team members or automation triggers to assign tasks directly to the agent to code, test, and open a pull request.

If you're looking to integrate one of these into a specific issue tracker like Jira or Linear , let me know your preferred tech stack or hosting requirements so I can recommend the best fit.

Several autonomous AI software engineers and agent platforms are designed to pick up an issue or ticket, write and run tests, and open a pull request without requiring you to drive the IDE.

The leading options capable of this end-to-end workflow include:

• Devin (by Cognition AI) — Widely recognized as the pioneer "AI software engineer," Devin operates in a secure cloud environment equipped with a terminal, browser, and code editor. You can assign tickets to Devin directly via integrations like Linear (by applying a label or assigning an issue) or GitHub, and it will autonomously research the codebase, write code, run tests, and open a pull request.
• Factory's Droid — Powered by Factory , Droid functions as a general-purpose agent that integrates into your engineering workflows. It can analyze incoming issues, triage them, map context from the codebase, implement fixes, and submit tested pull requests.
• Open-Source & Custom Agent Pipelines (e.g., SWE-agent, OpenClaw, or custom Claude Code setups) — Many engineering teams configure self-hosted or terminal-native agents like Claude Code or open-source frameworks combined with GitHub Actions or webhooks. By setting up trigger labels (e.g., labeling a GitHub Issue or Jira ticket as AI-agent ), a dispatcher script spins up the agent in a sandbox to code, run test suites, and open the PR automatically.
• Specialized Incident-to-PR Agents (e.g., Sherlock) — Emerging autonomous pipelines connect directly to issue trackers and observability platforms (like Jira and Sentry) to trace stack traces, generate code corrections, validate tests, and push a ready-to-review pull request.

If you want to try setting this up, let me know:

• What issue tracker you use (Jira, Linear, GitHub Issues)
• Your primary Git host (GitHub, GitLab)

I can help you figure out which tool fits your tech stack and security requirements.

Yes. If you mean “give the AI a GitHub/Jira ticket and have it independently implement the change, run tests, and open a PR”, the strongest options today are:

1. OpenAI Codex — my first pick

   • Takes an engineering task and works in an isolated repo environment.
   • Reads/edits code, runs tests, linters, and type checks.
   • Can work from issues and produce pull requests.
   • OpenAI has demonstrated an agent-first workflow where Codex can reproduce bugs, implement fixes, validate them, and open PRs; their internal team reports agents responding to review feedback and even squashing/merging PRs.

2. Devin

   • Probably the closest conceptual match to “AI software engineer”: assign it a ticket and let it work through the repository autonomously.
   • Particularly interesting if you want a persistent agent that can handle larger, multi-step engineering tasks.

3. GitHub Copilot coding agent

   • Very convenient if your workflow is already GitHub-centric.
   • Assign an issue/task to the agent; it creates a development environment, works on the repository, and produces changes for review.

4. Claude Code

   • Extremely capable autonomous coding agent, especially if you're comfortable giving it terminal/GitHub access and configuring your own automation.
   • More “agent you orchestrate” than an out-of-the-box ticket-to-PR engineering employee.

If I were setting this up for a team

I'd start with Codex if the desired workflow is:

GitHub issue → agent picks it up → understands repo → implements → adds/updates tests → runs test suite → fixes failures → opens PR → responds to review comments

That's now a very realistic workflow rather than just autocomplete. OpenAI's current Codex documentation explicitly describes end-to-end engineering work and background issue/CI tasks.

One important caveat: “tested PR” doesn't mean “correct PR.” Independent research of agent-authored PRs shows substantial variation by task type, and even successful agents still produce PRs that require human review.

If you tell me your stack (e.g. GitHub + Jira + Python/React, GitHub + Linear + TypeScript, etc.), I can tell you which one I'd deploy and exactly how I'd configure the ticket → tested PR pipeline.