Jira vs Linear for AI coding agents: MCP, CLI, credits and a live claim race (2026)

Radial makes this page. Jira and Linear are compared first, on the same evidence; the case for Radial is a separate section near the end.

Updated: 2026-11-02.

For most teams whose coding agents run in Claude Code, Codex or Cursor, Linear is the better fit of the two: Linear's MCP server lists 60 tools directly and scores 12.0 of 16 on the agent capabilities we track, measured live, against 8.0 for Jira's Rovo MCP server, compared from docs. Jira is the better fit when your agents work from a shell, because Jira ships an official CLI (acli, scored 12.0) and Linear ships no official issue-management CLI. Neither bills agents as seats. Both meter their own agents: Jira in Rovo credits, Linear in AI credits. Neither has a conditional claim, and on Linear we measured what that means: with 20 workers racing for one issue over 10 rounds, more than one worker was told "claimed" in 10 of 10 rounds, and 183 claims had their description marker overwritten by another worker with no error (one API key, so the assignee never changed). At list price, Jira Standard costs less than Linear Basic at every team size we priced: $950 against $1,200 a year for 10 people.

Two caveats belong up front. We ran Linear live on 2026-11-02 (its MCP tool list, a create-to-done flow, a claim race) and have not run Jira live: every Jira number here is compared from Atlassian's docs, and the Jira call count is an estimate. The Linear runs are scripted calls with no model time. Prices and limits were verified on Nov 2, 2026 on the vendors' pages, linked inline. The side-by-side table is also published as CSV, with a source URL and a verified date on every row.

#Jira vs Linear for coding agents, side by side

Download this table as CSV.

#MCP coverage

We score 19 things a coding agent does in a tracker against each official surface: yes = 1, partial = 0.5, no = 0. Three of the 19 rows describe features only Radial ships, so for Jira against Linear the 16 shared rows are the fair comparison. Linear is scored from the tool list its MCP server returned live on 2026-11-02 and its docs; Jira from Atlassian's supported tools page and the acli reference, read on Nov 2, 2026.

Download the full 19-row table, with Radial's columns, as CSV.

Linear's MCP server is the stronger of the two MCP servers: 11 yes plus 2 partial is 12.0, against Jira's 4 yes plus 8 partial, 8.0. Most of Jira's partials are round trips, not missing features: transitions, attachment upload and issue links exist, but behind discover plus executeRead or executeWrite, and every call needs a cloudId first. Jira keeps its direct tool list short that way, which trades schema bytes for calls.

Linear pays for its coverage in context. An MCP client loads the whole tools/list before the first call, and Linear's is 101,447 bytes for 60 tools, about 1,690 bytes a tool (L-LIVE-MCP-TOOLS). We have not measured Jira's tools/list bytes. Linear also offers a read-only endpoint, mcp.linear.app/mcp/readonly, for a reviewer agent that should never write.

Read the scores with two caveats. We picked the rows. And the scoring is uneven: Linear's cells come from a live tool list, Jira's from docs, which can leave out what a product does.

#CLI

Jira has an official CLI and Linear does not. That is the biggest single difference for agents that live in a terminal.

Jira: acli. 46 documented commands, --json on create, edit, search and transition, and --jql on edit, assign and transition, so one command updates a whole query's worth of issues. It scores 12.0 on the 16 shared rows, level with Linear's MCP server. Two upkeep costs: each acli version is supported for 6 months, and Jira API tokens expire after one year by default.

Linear: no official issue-management CLI. Linear ships two narrow official CLIs, linear-release for tracking releases and a CLI Importer for moving data in. An agent in a shell reaches Linear issues through the GraphQL API (writing queries and resolving workflow state ids), or through a community CLI such as schpet/linear-cli (1,034 stars, checked on Nov 2, 2026), which is maintained outside Linear. See the Linear CLI guide for the options.

#Are agents billed as seats?

Neither product bills an agent as a seat.

• Jira: not if the agent uses a person's token or a service account. Atlassian says service accounts "do not count towards your user limit. This means we don't charge your Jira or Confluence subscription plan for service accounts." Atlassian includes 5 free; more need Atlassian Guard Standard ($4.35 per user per month) or Enterprise (service accounts, Guard pricing).
• Linear: no. "Agents are not counted as billable seats in Linear." The same page adds: "The services that provide the agent may have their own pricing structure" (agents in Linear).

So the tracker bill is the people, if your agents share a person's token or fit in the 5 free service accounts. Give each agent its own service account past five and Jira needs Guard: Jira Standard plus Guard Standard is $1,472 a year for 10 humans and 20 agents, and $3,755 for 25 humans and 50 agents (Radial vs Jira cost CSV). At list price, Jira Standard costs less than Linear Basic at every size we priced, and Linear Business costs less than Jira Premium.

Sources and arithmetic: Radial vs Jira cost CSV and Radial vs Linear cost CSV. Jira's $9.70 is its price for new purchases from Oct 13, 2026; an existing customer keeps an older price until renewal. Both have free tiers: Jira Free covers 10 users, and Linear Free covers 250 issues and 2 teams.

#Rovo credits vs Linear AI credits

Both vendors meter AI work in credits, and they meter different things.

Jira: Rovo credits. Standard includes 25 credits per user per month, Premium 70, Enterprise 150, in one shared pool with no rollover. From December 3, 2026, usage past the pool bills at "$0.01 per Rovo credit", and extra usage "is enabled by default" (credits). Your own agent pays credits through Rovo MCP: writes and single-issue lookups are free, but the cross-product search tool "may consume up to 10 Rovo credits per call". Rovo agents draw credits "each time an agent is invoked", at a rate Atlassian does not publish.

The overage math for a team of 10 on Standard: the pool is 250 credits a month (10 x 25), which covers 25 search calls at the 10-credit maximum. 1,000 agent search calls a month is up to 10,000 credits. The pool absorbs 250, so up to 9,750 bill as overage: 9,750 x $0.01 = up to $97.50 a month. An agent that sticks to searchJiraIssuesUsingJql, single-issue reads and writes stays near zero.

Linear: AI credits. Only Linear's own agent work draws them: coding sessions and Loops. "Other Linear AI features are included in your plan and do not draw from your AI credits balance." Your own agent calling Linear's MCP server or API draws none, per the pages we read. Credits are opt-in and prepaid, pooled across the workspace, and expire 12 months after purchase. The minimum top-up is $10 and automatic reload starts at $50. Linear does not publish how many credits each plan includes (AI credits).

For a team that brings its own agents, Linear's meter does not move at all and Jira's moves only on cross-product search. The meters matter when you run the vendor's agent.

#Rate limits

• Jira REST: 100 requests per second for GET and POST, 50 for PUT and DELETE, per endpoint bucket, plus 20 writes per 2 seconds on one issue. A 429 says which limit hit (RateLimit-Reason) and how long to wait (Retry-After). OAuth apps also draw from an hourly points quota (rate limiting).
• Jira Rovo MCP: 500 calls an hour on Free, 1,000 on Standard, per site; Premium and Enterprise add 20 calls per user, up to 10,000 an hour (Rovo MCP). A user on the Atlassian MCP GitHub tracker reported 429s "after roughly 20 parallel calls" with no rate-limit headers to read (issue #171).
• Linear API key: 2,500 requests and 3,000,000 complexity points per hour, about 41.7 requests a minute. An OAuth app gets 5,000 requests and 2,000,000 points per hour per user. One query is capped at 10,000 complexity points, so an agent fetching issues with nested comments pages in smaller chunks (rate limits).

A swarm of agents sharing one Linear API key shares 2,500 requests an hour. A swarm on Jira Standard's Rovo MCP shares 1,000 calls an hour for the whole site; over the REST API or acli, the per-second burst limits apply instead.

#Agent workflow: call counts

The same four steps on each: take the next unassigned issue, mark it started, post proof, close it. Issue creation and a closing note are left out of every count.

Linear MCP: 4 tool calls, run live, n=5. list_issues for the next one, save_issue with assignee: "me" and a started state, save_comment for the proof, and save_issue with a completed state. Those four calls took a median 2,100 ms combined (min 1,651, max 2,432). The run also created the issue first and posted a done note after, 6 calls in all: median 3,187 ms per 6-call flow (min 2,608, max 3,293), about 9.1 KB read back (L-LIVE-T1T4). These are scripted calls against mcp.linear.app/mcp, with network and server time but no model time. Statuses go by name.

Jira Rovo MCP: about 9 tool calls, an estimate counted from the documented tool list, not run:

1. getAccessibleAtlassianResources for the cloudId every other call needs.
2. atlassianUserInfo for the agent's account id.
3. searchJiraIssuesUsingJql for the next issue.
4. editJiraIssue to set the assignee.
5. discover, because listJiraIssueTransitions is a deferred tool.
6. executeRead to run listJiraIssueTransitions and get the transition id for "In Progress".
7. transitionJiraIssue with that id.
8. addOrEditJiraIssueComment with the proof.
9. transitionJiraIssue again for "Done".

None of those is an enriched call, so none should draw Rovo credits. The cost is round trips, and an agent can group several into one turn.

Jira acli: 5 commands, from the command reference:

acli jira workitem search --jql "project = ENG AND assignee is EMPTY AND status = 'To Do'" --limit 1 --json
acli jira workitem assign --key "ENG-42" --assignee "@me"
acli jira workitem transition --key "ENG-42" --status "In Progress"
acli jira workitem comment create --key "ENG-42" --body "Root cause: retry loop never backed off. Fixed in #412."
acli jira workitem transition --key "ENG-42" --status "Done" --yes

Linear's equivalent without MCP is 5 GraphQL requests, including a lookup of the team's workflow state ids. The two flows are not a speed comparison: we timed Linear and not Jira.

#Two agents, one issue: the claim race

When two agents reach for the same issue, a plain assign is last-write-wins: both agents get a success, and one of them works on an issue it does not own.

Linear, measured live (L-LIVE-RACE). Linear has no conditional update, so we raced the claim an agent can write: read the issue and, if it is still in Todo, call issueUpdate to assign and start it. 20 workers per round, 10 rounds, one fresh issue per round.

One caveat: all 20 workers used one Linear API key from 20 threads, so every update set the same assignee. Each worker wrote its own marker into the description, and 183 is the successes past the first in each round: claims whose marker another worker overwrote. The run measures double claims and description overwrites under one identity, not a change of assignee. Separate identities add no precondition to issueUpdate, so we expect the assignee to be overwritten the same way, but we have not run it. Linear's delegate model and agent sessions are built for one agent per issue, which avoids the race when an orchestrator hands out the work; agents that pick their own work from a shared queue hit it.

Jira, not run live. Jira documents no conditional assign, so by its docs an editJiraIssue or acli jira workitem assign race should behave the same way. We have not raced it, and a Jira trial is pending.

#Enterprise setup and hidden costs

Sources: Radial vs Jira hidden costs, enterprise setup; Radial vs Linear hidden costs, enterprise setup.

#Both vendors ship their own agents

Both Atlassian and Linear sell a tracker and run an agent inside it. Stated as each documents it:

• Jira: Rovo. Rovo is Jira's AI layer, and Rovo agents work on work items, drawing Rovo credits each time an agent is invoked. On July 15, 2026, Atlassian announced Jira capabilities for "AI-native software development", positioning Jira as the place to plan, assign, govern and measure work across both humans and AI agents. Third-party agents connect through Rovo MCP, acting "with your existing permissions".
• Linear: Linear Agent. Linear Agent is "available by default in your workspace" and can "create and update work like issues, projects, milestones and initiatives" (docs). Coding sessions (2026-09-24) let it write and test code in a cloud environment; Loops (2026-07-20) take on recurring work. Both draw AI credits. Linear also calls itself "an open platform for third party agents": partners listed include Cursor, OpenAI Codex, Devin, Sentry, Factory and GitHub Copilot (developer docs).

For a team that brings Claude Code or Codex, both products work as the shared state. The vendor agents are an option you pay for in credits, not a requirement.

#Verdict: who should pick Jira, who should pick Linear

Pick Linear if your engineering team runs agents through MCP and you want:

• The stronger MCP server: 60 tools listed directly, 12.0 of 16 against Jira's 8.0, with statuses by name and no cloudId round trip.
• A delegate model that keeps the human owner on an agent's issue, and agent-session webhooks that wake agents instead of polling.
• A read-only MCP endpoint for reviewer agents.
• A free tier for a small project (250 issues), or a tracker that runs its own coding agent.

Pick Jira if:

• Your agents work from a shell and you want an official CLI: acli scores 12.0 and bulk-edits by JQL.
• You need SAML SSO without an Enterprise contract (Guard Standard), per-project permission schemes, or user-activity audit logs.
• Other departments already share Jira, or the company is on Atlassian.
• You want the lowest list price of the two paid plans ($950 against $1,200 a year for 10 people), or free for up to 10 users.

Either way, plan for the claim race: neither has a conditional claim, so agents that pick their own work from a shared queue need an orchestrator or a lock outside the tracker.

#A third option built for agents

Radial makes this page, so weigh this section accordingly; the evidence is the same as above. Radial is a hosted issue tracker built for teams running coding agents. It is a standalone product with its own web app, CLI, MCP server and REST API, not an app inside another vendor's tracker.

Vendor-neutral. Radial runs no agent and ships no AI features, so there are no credits. Your agent, your model, your keys: Claude Code, Codex or any MCP client does the work.

An official CLI and an official MCP server. The radial CLI 1.3.0 has 32 top-level commands and --json on every command that returns data; it scores 13.0 on the 16 shared rows, against 12.0 for acli. Radial's hosted MCP server lists 45 tools in a 21,020-byte tools/list, measured live (R-LIVE-MCP-TOOLS), about 470 bytes a tool against Linear's 1,690, and scores 13.5 against Linear's 12.0 and Jira's 8.0. Radial is scored from its own source, which shows everything it does, so treat the gap as a range, not a verdict.

The screenshot shows the local radial mcp server over stdio, run offline with no account: 41 tools at the time of capture, then every tool name. The local server now lists 42 tools, with claim_issue added since; it lacks the hosted server's attachment tools.

An atomic claim. radial claim ENG-42, claim_issue over MCP, or POST /v1/issues/{id}/claim is one conditional write that assigns only if nobody holds the issue. It is live in production. Exactly one claimant wins; every other gets a 409 naming the holder, and the CLI exits 3 so the agent moves on. Our evidence is Radial's race tests: a unit test with 12 concurrent claimants and an integration test with 8 agent keys against a real database. We have not run a live multi-identity race against production yet, so this is tested, not measured like Linear's race (R-CLAIM-ATOMIC).

Agents are not billed, and nothing is metered. Agents are workspace members marked as agents, and the billing code leaves them out of the seat count. Radial costs $50 per user per year, flat.

The two charts show the same four team sizes. Against Jira: Radial $50, $150, $500 and $1,250 a year, Jira Standard $116.40, $349.20, $950 and $2,450, Jira Premium $235.20, $705.60, $1,950 and $4,900. Against Linear: Linear Basic $120, $360, $1,200 and $3,000, Linear Business $192, $576, $1,920 and $4,800. See Radial pricing, or eight trackers in what is a cost-effective issue tracker.

Where Radial is behind, honestly:

• A younger product, with a smaller integration ecosystem than either, and no presence indicators or multiplayer editing.
• No free tier, no trial, no monthly plan. Jira Free and Linear Free both cost $0.
• Cannot be self-hosted, and is not open source.
• No SAML SSO or SCIM. Email and password, or Google.
• No read-only MCP endpoint, which Linear has; give a reviewer agent a key with the read scope instead. No per-project agent permissions: Radial key scopes cover the whole workspace, where Jira has permission schemes.
• No webhooks API (settings UI only), no delegate field (a claim makes the agent the assignee), and no push to agents: Radial agents poll.
• No bulk edit in the CLI, which acli has. Bulk update is on MCP and REST only.
• Limits: 120 requests per minute per credential, burst 120, enforced per server instance, and a 429 carries no Retry-After yet.
• No published uptime figure, status page or support response time.

For the full head-to-heads, read Radial vs Jira and Radial vs Linear.

#Methodology

• Live Linear, 2026-11-02: tools/list against mcp.linear.app/mcp, server 1.0.2 (L-LIVE-MCP-TOOLS); the create, claim, proof and done flow over MCP, n=5, scripted calls with no model time (L-LIVE-T1T4); the claim race, 20 workers x 10 rounds, read then issueUpdate, one API key (L-LIVE-RACE).
• Jira, from docs: coverage, the 9-call MCP estimate and the acli flow come from Atlassian's supported-tools page and acli reference, read on Nov 2, 2026. Nothing ran live against Jira; a Jira trial is pending.
• Live Radial: tools/list against mcp.radial.build/mcp (R-LIVE-MCP-TOOLS). The atomic claim's evidence is Radial's unit and integration race tests (R-CLAIM-ATOMIC). Radial is scored from source at commit 9126321.
• Coverage: 19 rows, 16 shared, scored yes = 1, partial = 0.5, no = 0. The full table, with every source, is in the coverage CSV.
• Raw data: every evidence id links to its raw file under benchmarks/runs/2026-11-02; the full index is evidence.json.
• Not measured yet: any live Jira run (round trips, credit draw, MCP limits, a claim race), a multi-identity Linear race, and a live Radial task flow. Nothing here claims one product is faster per task than another.

#FAQ

#Is Jira or Linear better for AI coding agents?

For agents that work through MCP, Linear: its MCP server lists 60 tools directly and scores 12.0 of 16 on our agent capabilities, measured live, against 8.0 for Jira's Rovo MCP server, compared from docs. For agents that work from a shell, Jira: it ships an official CLI, acli, which scores 12.0, and Linear ships no official issue-management CLI. Jira Standard also costs less at list price: $950 against $1,200 a year for 10 people.

#What is the best issue tracker for Claude Code?

Between Jira and Linear, Linear, because Claude Code connects to trackers through MCP and Linear's MCP server covers more (12.0 against 8.0 of 16). If you want an official CLI and MCP server, agents not billed, no credits and an atomic claim, Radial is built for that: its hosted MCP server has 45 tools in 21,020 bytes and scores 13.5, at $50 per user per year. Radial makes this page, so check the evidence links.

#Does Linear or Jira charge for AI agents?

Neither bills agents as seats. Linear says "Agents are not counted as billable seats in Linear." Jira does not bill service accounts (5 free, more with Atlassian Guard) or an agent using a person's token. Both meter their own agents: Linear Agent coding sessions cost model tokens at provider rates plus $0.25 per 20-minute sandbox block, and Rovo agents draw Rovo credits. On Jira, your own agent's cross-product search may use up to 10 Rovo credits per call, $0.01 each past the pool from December 3, 2026.

#Does Linear have an official CLI like Jira's acli?

No. Linear ships linear-release and a CLI Importer, neither of which manages issues. Agents reach Linear issues through the MCP server, the GraphQL API, or community CLIs such as schpet/linear-cli. Jira's acli has 46 documented commands, --json output and bulk edits by JQL.

#Can two agents claim the same issue in Jira or Linear?

On Linear, yes, measured. On Jira, no conditional assign is documented; we have not tested it. Neither documents a conditional claim, so a plain assign is last-write-wins. In our live race against Linear, 20 workers over 10 rounds, more than one worker was told "claimed" in 10 of 10 rounds, and 183 claims had their description marker overwritten by another worker with no error (one API key, so the assignee never changed). We have not raced Jira live; it documents no conditional assign.

#What are the API rate limits for agents on Jira and Linear?

Linear allows 2,500 requests and 3,000,000 complexity points per hour on an API key, and 5,000 requests and 2,000,000 points per hour per user on an OAuth app. Jira's REST API allows 100 requests per second for GET and POST and 50 for PUT and DELETE, and its Rovo MCP server allows 500 calls an hour on Free and 1,000 on Standard, per site.

#Is Radial an Atlassian or Linear app?

No. Radial is a standalone, hosted issue tracker with its own web app, CLI, MCP server and REST API. It imports Jira and Linear data, and then your team and your agents work in Radial.