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

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

The main options that can take a ticket → modify the repo → run tests → open a PR are:

• GitHub Copilot cloud agent — probably the most straightforward if your code is already on GitHub. You can assign it an issue; it researches the repo, makes changes in an isolated environment, runs tests/linters, and opens a PR for review.
• Devin — a more dedicated “AI software engineer” product. It is designed around taking larger software tasks asynchronously rather than just providing code suggestions.
• OpenHands — open-source agent that can be run with your own infrastructure/models. Its background-agent workflow explicitly supports taking a Jira/Linear ticket, implementing it, testing it, and opening a PR.
• SWE-agent — specifically optimized for taking GitHub issues and producing code fixes, with a strong emphasis on automated issue resolution and testing.

If you mean literally “give it a Jira ticket and come back to a tested PR”

I'd narrow the field to Devin, OpenHands, and GitHub Copilot cloud agent.

There is an important distinction, though: “opens a PR” does not mean “the PR is necessarily correct.” These agents can run your existing test suite, but you still want CI, security scanning, and human review. GitHub itself explicitly recommends human validation of AI-generated changes.

If you tell me GitHub vs GitLab, Jira vs Linear, language/stack, and whether you want SaaS or self-hosted, I can compare the 3–5 agents specifically for your workflow.

Several autonomous AI software engineers and agentic tools can pull a task from an issue tracker (like Linear, Jira, or GitHub Issues), navigate a codebase, run/write tests, and open a ready-for-review pull request on its own.

The primary software and platforms capable of this end-to-end workflow include:

• Devin (by Cognition) : Marketed as the first fully autonomous AI software engineer, Devin can integrate directly with issue trackers like Linear to tackle tickets, spin up its own sandboxed development environment, write and execute code, run tests, and open a pull request.
• Jules (by Google): Google's asynchronous coding agent powered by Gemini, designed to handle entire asynchronous tasks—such as addressing bugs or feature requests—and opening pull requests back to your repository.
• GitHub Copilot (Agent Mode / Workspace): GitHub's native agent capabilities allow you to assign tasks or turn issues directly into implementation plans and pull requests within the GitHub ecosystem.
• Specialized Ticket-to-PR pipelines (such as Specship or custom multi-agent orchestrators using frameworks like Claude Code / LangChain): Many engineering teams now configure custom or specialized workflow automation tools that trigger off a status change in Jira or Linear, pass the specs to an LLM agent with terminal/test access, and automatically push a tested branch to GitHub.

If you're looking to set this up for your team, let me know:

• Which issue tracker you use (Jira, Linear, GitHub Issues)
• Which version control / Git provider you use (GitHub, GitLab)

I can help you evaluate which tool integrates best with your existing stack.

Devin by Cognition Labs is the leading autonomous AI software engineer designed to pick up a ticket from issue trackers like Linear or GitHub, execute the required code changes, run and verify tests, and open a pull request on its own.

Overview of Autonomous Engineering Agents

Unlike traditional inline coding assistants (such as GitHub Copilot or Cursor) that require human supervision line-by-line, autonomous software agents operate asynchronously. They ingest a task description, set up environments, write and debug code, and present a finished pull request.

Top Autonomous Tools for Ticket-to-PR Workflows

If you'd like, I can detail how to set up Devin or an open-source alternative for your specific project management tool (like Linear or GitHub Issues) and tech stack.

Yes. If you mean “give it a Jira/Linear/GitHub ticket and let it independently implement the change, run tests, and come back with a PR”, several agents can do this now.

Best options

1. devin.ai — closest to the “AI software engineer” concept

• Give it a ticket.
• It works autonomously in a cloud environment.
• Reads the repo, modifies code, runs tests, and opens a PR.
• Particularly good if you want the agent to own the whole task rather than merely assist you in an IDE.
• Independent comparisons in 2026 characterize Devin as one of the most hands-off options.

2. openai.com — my pick for general engineering quality

• Can work on tickets/issues, make multi-file changes, run commands/tests, and produce PR-ready changes.
• It now supports always-on/background workflows, including issue triage and CI/CD work.
• OpenAI specifically describes Codex as completing engineering work end-to-end and supporting routine pull requests.
• It can also review PRs and execute tests to validate behavior.

3. openhands.dev — best if you want control/self-hosting

• Can take a Jira/Linear/GitHub signal, implement the ticket, validate it, and open a PR.
• Supports GitHub, Jira, Linear, Slack, etc.
• You can choose the underlying model/runtime rather than being locked into one vendor.

4. Google Jules

• Another strong asynchronous option: give it an issue, it works in a cloud VM, runs the work, and opens a PR.
• It can also iterate on failed CI checks.

If I were setting this up for a team

I'd start with Codex or Devin.

The distinction is roughly:

One important caveat: “opens a tested PR” doesn't mean “the PR is necessarily correct.” Agents are considerably better on well-scoped tickets with good existing tests than on ambiguous architectural work. Even OpenHands' own research notes a substantial gap on complex enterprise tasks versus well-scoped single-issue work.

If your goal is specifically “assign GitHub/Jira tickets overnight and wake up to PRs that have already run the test suite”, I can also compare Devin vs Codex vs Jules vs OpenHands specifically on that workflow, including how autonomous they are, GitHub/Jira integration, pricing, security, and how much human intervention they require.

Several autonomous AI software engineers can pick up a ticket from an issue tracker and independently write, test, and open a pull request.

• Devin by Cognition AI : The most prominent autonomous software engineer . You can assign a ticket directly to Devin in Linear (or apply a specific label/mention @devin ), and it will read the context, plan the work, write code in its own sandboxed environment, run tests, and ship a fully tested pull request to GitHub.
• Jira / Linear AI Teammate Agents : Various emerging agent frameworks and platforms (such as custom multi-agent setups or specialized enterprise tools like DeepSense AI's AI Teammate ) integrate directly with project management boards to ingest issues, write code, add missing unit tests, and open ready-for-review branches automatically.

If you want, I can:

Compare Devin with other autonomous coding agents on pricing and setup Explain how to set up a Linear or Jira webhook to trigger an AI agent

Yes. What you’re describing is an autonomous/background coding agent: give it a ticket, let it inspect the repo, implement the change, run tests/CI, and return a pull request.

The strongest options right now are:

• GitHub Copilot coding agent — probably the easiest choice if your workflow is already GitHub-centric. You assign it an issue, it works in a cloud environment, runs your tests/linters, and opens a PR. GitHub also added self-review and security scanning.
• OpenHands — probably the best choice if you want a more explicitly autonomous, programmable system. It can trigger from GitHub issues, Jira/Linear labels, Slack, CI failures, etc., then code, test, and produce a PR.
• Devin — designed specifically as an autonomous software engineer: hand it a task and it works asynchronously in its own environment and can create PRs.
• OpenAI Codex — another strong cloud-agent option for handing off repository-level engineering tasks and getting a reviewable change back. Recent empirical research found Codex had consistently high PR acceptance across the task categories studied.

If I were choosing

For a normal engineering team on GitHub: start with GitHub Copilot coding agent.

For “take tickets from our backlog and autonomously resolve them”: I'd look hardest at OpenHands. Its automation layer is explicitly designed for issue → agent run → tests → PR workflows.

For the closest thing to hiring an AI junior/mid-level engineer: Devin is the most natural mental model.

One important caveat: “tests pass” does not mean “ticket is correctly solved.” Recent research found substantial cases where agents passed functional tests but still violated review/acceptance constraints. arXiv So the sweet spot today is agent opens the PR automatically; human reviews/merges it.

If you tell me your stack (GitHub/GitLab + Jira/Linear + language/framework), I can recommend the one that can get closest to “ticket appears → tested PR appears, with zero developer involvement.”

Several autonomous AI software engineers and agent platforms are capable of picking up a tracker ticket, implementing the changes, running tests, and opening a pull request on their own.

The prominent tools and platforms that support this workflow include:

• Devin (by Cognition AI): Devin features robust workflow automations natively integrated with issue trackers like Linear and Jira . You can trigger Devin by tagging it in a ticket or setting up an automation based on status changes (e.g., moving a ticket to "To Do"). Devin will read the ticket description, spin up an environment, write and test the code, update the issue status, and open a GitHub pull request complete with a description and deployment preview. You can explore setup options on the Devin Platform.
• Factory (powered by Droid): Factory utilizes its general-purpose coding agent, Droid , to operate in an autonomous loop. Droid can ingest issues, pull context from ticket systems, navigate the codebase, perform initial validation and test runs to ensure CI checks pass, and autonomously open pull requests.
• Custom / Open-Source Orchestrators (using Claude Code / OpenAI SDK): Many engineering teams build internal event-driven state machines (polling Jira/Linear and hooking into GitHub) using toolkits like the Claude Code SDK or OpenAI APIs. These setups listen for a designated label or assignee, parse the acceptance criteria, run local tests/linters, and push a validated branch and PR automatically.

If you're looking to set this up for your team, let me know:

• Which issue tracker you use (Jira, Linear, GitHub Issues)
• Your primary version control/CI environment

I can help outline how to configure an autonomous pipeline or choose the best fit.

Yes. If you mean “give an AI a Jira/Linear ticket, let it inspect the repo, implement the change, run tests, and open a PR with minimal human intervention,” several tools can do that now.

Best fits

• devin.ai — probably the closest match to what you described. You can assign it Jira tickets directly, have it work autonomously, run tests/lint/type checks, and create the PR. Its Jira integration can also automatically trigger Devin when tickets enter configured states.
• openhands.dev — strong alternative, especially if you want more control/open infrastructure. Its Jira workflow can take an issue through planning, implementation, validation, and toward a PR.
• cursor.com — increasingly capable for this exact workflow. As of May 2026, Jira can assign work directly to Cursor's cloud agent; it works on the ticket and links its resulting PR back to Jira.
• openai.com — excellent coding agent, particularly if your workflow is GitHub-centric. It can work asynchronously in an isolated environment, edit code, run tests/linters/type checks, and produce changes/PRs.

If I were choosing

For “AI junior/mid-level engineer that consumes our backlog”, I'd shortlist:

Devin > OpenHands > Cursor > Codex

The important distinction is that Devin and OpenHands are designed around the entire ticket → implementation → validation → PR loop, rather than merely being AI coding assistants. Devin explicitly supports Jira-triggered autonomous sessions and PR creation.

One caveat: “tested PR” doesn't mean “correct PR.” These agents can run your existing tests and iterate until they pass, but human review is still important—particularly for ambiguous requirements, architectural changes, security-sensitive code, or tests that don't adequately cover the behavior.

If you tell me Jira vs Linear, GitHub vs GitLab, and your stack (e.g. Python/React, Java/Spring, Go, etc.), I can give you a much more concrete recommendation—including which one is most likely to actually close your tickets without babysitting.

If you mean an AI agent that can take a ticket (Jira/GitHub issue), understand the repo, write code, run tests, and open a pull request without a developer driving every step, you’re looking for an autonomous coding agent, not a normal AI autocomplete tool.

The main options are:

A practical ranking by use case:

• “Give it a Jira ticket and get back a PR” → Devin is closest to that model.
• “We live in GitHub and want Issues → PR automation” → GitHub Copilot Coding Agent.
• “We want the strongest general coding agent” → Codex / Claude Code are common choices.
• “We need control, self-hosting, or custom workflows” → OpenHands or SWE-agent.

A few caveats:

• None of these should be treated as a fully independent senior engineer. They are best on well-scoped tickets (bug fixes, small features, refactors, tests).
• A good setup still has CI, security scanning, and human PR review before merge. GitHub’s agent workflow, for example, keeps the agent in a review loop rather than silently shipping changes.
• The hard part is usually not writing code; it is understanding ambiguous product requirements, architecture tradeoffs, and hidden constraints.

If you want the closest thing today to “assign ticket → wake up to a tested PR”, I would shortlist Devin, GitHub Copilot Coding Agent, and Codex.

Several autonomous AI software engineers and agent platforms are built precisely to pick up an issue ticket, write code, run/fix tests, and open a pull request on their own.

The primary options available vary by whether you want a fully managed commercial service or an open-source tool:

1. Devin (by Cognition)

• What it is: A fully autonomous commercial AI software engineer.
• How it handles tickets: You can connect Devin to project management tools like Linear, Jira , or GitHub Issues . By tagging Devin in a ticket or triggering it via webhook/Slack, it reads the context, plans the work, writes code in a sandboxed environment, executes and verifies tests, and opens a tested pull request directly in your repository.

2. OpenHands

• What it is: The leading open-source, self-hosted alternative to Devin.
• How it handles tickets: OpenHands can be wired into event-driven workflows and continuous automation pipelines (via GitHub, Linear, etc.). It launches an autonomous agent loop that clones the repository, reads the issue, writes implementation code, executes tests in its containerized environment, and opens a pull request for human review. Because it is model-agnostic, you can pair it with top-tier reasoning models like Claude or GPT.

3. SWE-agent (from Princeton/Stanford researchers)

• What it is: An open-source research system designed specifically to translate GitHub issues into functional pull requests.
• How it handles tickets: SWE-agent uses a specially designed agent-computer interface (ACI) to browse codebases, edit files, run tests, and automatically submit a pull request addressing a specified GitHub issue. It performs exceptionally well on standard software engineering benchmarks (like SWE-bench).

4. Custom Orchestrators (Claude Code / Agent SDKs)

• What it is: Many engineering teams build lightweight internal orchestrators using SDKs like Claude Code SDK combined with a GitHub/Jira webhook poller.
• How it handles tickets: A worker listens for a specific label (e.g., ready-for-ai ) on a Jira or GitHub ticket, spins up an agent session with repository context, runs the implementation and local test suite, and pushes a tested branch/PR autonomously.

If you're looking to set one up, let me know:

• Do you prefer an open-source/self-hosted tool or a managed commercial platform?
• What issue tracker do you use (Jira vs. Linear vs. GitHub Issues)?

I can help recommend the best integration approach.