Radial vs Linear for coding agents: CLI, MCP, prices and a live claim race (2026)

Pick Radial if your coding agents live in a terminal and you want a tracker they can drive with a first-party CLI, a 45-tool MCP server, build records and prototype previews, for $50 per user per year, flat, with agents not billed as seats and no credits. Pick Linear if you want a free tier, SAML and SCIM on Enterprise, webhooks over the API, a delegate model that keeps the human owner on an agent's issue, or a tracker that runs its own agent. Linear ships no official issue-management CLI, so agents reach it through its hosted MCP server or the GraphQL API. On the 16 capabilities both products can have, Radial's MCP server scores 13.5 and Linear's 12.0, with Linear scored from its live tool list; Radial's CLI scores 13.0. Linear's MCP server lists 60 tools in a 101,447-byte tools/list, Radial's hosted server 45 tools in 21,020 bytes. In a live race of 20 workers over 10 rounds, a read-then-update claim on Linear told more than one worker "claimed" in 10 of 10 rounds; Radial's claim is one conditional write with exactly one winner. At 10 people plus 20 agents, Radial costs $500 a year, Linear Basic $1,200 and Linear Business $1,920; at 25 people plus 50 agents, $1,250, $3,000 and $4,800. Linear Free costs $0 up to 250 issues.

Two caveats belong up front. We scored Radial from its source code and Linear from its docs plus a live tools/list call, and the Linear runs are scripted calls with no model time. On 2026-11-02 we ran Linear's MCP server and API live: the tool list, a create-to-done flow (n=5) and a 20-worker claim race. No Radial task flow has run live yet, so nothing here compares speed per task. Both products are keyboard-first and in the cloud, and neither bills agents as seats. The differences are the agent surface, the meter, and whether the tracker brings its own agent. Every number below is dated 2026-11-02: Linear prices and limits were verified on Nov 2, 2026, Radial facts come from its source code, and the few measured numbers are labeled with n and an evidence id (see Methodology).

#What it costs with agents

Radial costs $50 per human per year and $0 per agent, with no credits. Linear Basic costs $10 per human per month and Business $16, both billed yearly; Linear Free costs $0 up to 250 issues and 2 teams. Neither bills agents as seats. Linear's own agent work (coding sessions and Loops) draws prepaid AI credits.

Are agents billed as seats?

• Radial: no. Agents are workspace members marked as agents (is_agent), and the billing code leaves them out of the seat count. No credits, no meter.
• 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).

The chart shows yearly cost at four team sizes. At 1 human plus 3 agents: Radial $50, Linear Basic $120, Linear Business $192. At 3 humans plus 5 agents: $150, $360 and $576. At 10 humans plus 20 agents: $500, $1,200 and $1,920. At 25 humans plus 50 agents: $1,250, $3,000 and $4,800.

Download this table as CSV.

Assumptions, so you can redo the math for your team:

• Prices are list prices from the Linear pricing page, verified on Nov 2, 2026, in USD, with no tax. Linear shows only billed-yearly prices. Its billing docs say monthly billing exists ("we offer either monthly or yearly options"), but the monthly price is not published, so the per-month figures above are the yearly price divided by 12. Radial bills yearly only.
• Agents are free in both products, so only the humans count.

Linear plan limits that hit agents:

• Free: 250 issues, 2 teams, 10MB file uploads, with unlimited members, MCP, the API and the agent platform included. Agents can file many issues a day, so 250 is a ceiling a team of agents can reach in weeks.
• Basic: 5 teams, unlimited issues and uploads. Business and Enterprise: unlimited teams.
• API: 2,500 requests and 3,000,000 complexity points per hour on an API key, about 41.7 requests a minute; an OAuth app gets 5,000 requests and 2,000,000 points per hour per user (rate limits, verified on Nov 2, 2026).

Linear AI credits: coding sessions and Loops need them; "Other Linear AI features are included in your plan and do not draw from your AI credits balance." 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).

Download this table as CSV.

For a solo developer trying things out, Linear Free costs nothing and Radial has no free tier. Past the free limits, Radial is one plan: $50 per user per year, flat, agents not billed as seats, nothing metered. See Radial pricing, or compare eight trackers in what is a cost-effective issue tracker.

#Can I use an issue tracker like Linear as the work queue that orchestrates my Claude Code agents?

Yes, if one orchestrator hands out the work. No, not safely, if several agents pull their own work from a shared queue. A work queue needs one thing a plain tracker update does not give: an atomic claim, so two agents that reach for the same issue cannot both get it.

• Linear works when an orchestrator assigns. Its delegate model and agent sessions are built for one agent per issue: a person or a script delegates the issue, and the agent works it (agents in Linear). Linear can also push work to an agent app through agent-session webhooks.
• Linear double-claims when agents pull. Linear has no conditional update, so a claim is a read and then an issueUpdate. In our live race on Nov 2, 2026 (20 workers, 10 rounds, one API key), more than one worker was told "claimed" in 10 of 10 rounds, and 183 claims were overwritten with no error (L-LIVE-RACE; details below).
• Radial's queue loop is three commands. radial claim is one conditional write: it assigns the issue only if nobody holds it, and every other claimant gets a 409 naming the holder (the CLI exits 3), so the agent moves on to the next issue.

radial list --assignee unassigned --status Todo --limit 1 --json   # the next issue
radial claim ENG-42 -s "In Progress" || echo "taken, pick another"  # exit 3: another agent has it
radial close ENG-42 -m "Fixed in #412"                               # done, with a note

Over MCP the same loop is list_issues, claim_issue and close_issue; over REST, POST /v1/issues/{id}/claim. What Radial's queue does not do today: it has no push to agents (an agent polls radial list or radial inbox), and a claim has no lease or timeout, so an issue held by an agent that crashed stays assigned until a person or another agent reassigns it. For the full pattern with worktrees, see running parallel agents.

#What is a good Linear alternative that works well with Claude Code and Codex?

Radial, if your agents work in a terminal. Claude Code and Codex both run shell commands, and Linear has no first-party issue CLI: its official linear-release CLI tracks releases, and its importer moves data in, but neither creates, claims or closes issues. An agent reaches Linear issues through the hosted MCP server, the GraphQL API, or a community CLI. Radial ships the radial CLI with --json on every command that returns data, plus a hosted MCP server that lists 45 tools in 21,020 bytes, against Linear's 60 tools in 101,447 bytes (both measured on Nov 2, 2026).

The second difference is the meter. Linear's own agents cost money per run: Linear Agent coding sessions bill model tokens at provider-published rates plus $0.25 per 20-minute sandbox block, and Loops cost $0.07 to $0.20 per run, from prepaid AI credits (AI credits, as of Nov 2, 2026). Your own Claude Code or Codex calling Linear's MCP server draws no credits, per the pages we read. Radial runs no agent of its own and meters nothing.

Connecting either agent to Radial:

npm i -g radial.build && radial auth
claude mcp add --transport http radial https://mcp.radial.build   # Claude Code, hosted MCP over OAuth
radial skills install                                             # rd-* skills for Claude Code and Codex
radial build hook install --client codex                          # keep each Codex session on its issue

For Codex's MCP connection, add the local server to ~/.codex/config.toml:

[mcp_servers.radial]
command = "radial"
args = ["mcp"]

Linear still wins on a free tier, a delegate field, webhooks that wake agents, SAML and SCIM, and its own agent if you want one. If you are choosing between Linear and Jira for the same agents, read Jira vs Linear for AI coding agents.

#Key facts, side by side

Download this table as CSV.

#Agent-surface coverage, scored

We scored 19 things a coding agent does in a tracker against each official surface: yes = 1, partial = 0.5, no = 0. Radial is scored from its source code, Linear from the tool list its MCP server returned live and its docs, and Jira from its docs. Three rows (marked *) describe features only Radial ships, so we lead with the 16 shared rows.

On the 16 shared rows: Radial CLI 13.0, Radial MCP 13.5, Linear MCP 12.0, Jira CLI (acli) 12.0, Jira MCP (Rovo) 8.0. On all 19 rows: Radial CLI 16.0, Radial MCP 15.5, Linear MCP 12.0, Jira CLI 12.0, Jira MCP 8.0. Linear has no official issue-management CLI, so it has no CLI column.

Download this table as CSV.

The arithmetic for Linear MCP: 11 yes (create, update, search, comments, transitions, labels, attachments, relations, notifications, auth, headless) plus 2 partial (projects and cycles, claim) is 12.0. From docs alone, 8 of those cells were unknown and the score was a range of 7.0 to 15.0. The live tools/list resolved all 8: transitions, labels, attachments, relations and notifications are yes; bulk, webhooks, and import and export are no, because the 60 tools include none for them. Linear scores 0 on the three Radial-only rows, so it scores 12.0 on 16 rows and on 19. Radial is scored at commit 9126321, before the atomic claim (radial claim, claim_issue) shipped, so its claim row still reads partial; we left it there until the next full re-score. The Jira MCP cells for bulk, webhooks and relations come from Atlassian's supported tools page, read on Nov 2, 2026.

Four caveats, in Linear's favour:

• The live list moved Linear up. Scored from docs alone, Linear's floor was 7.0. Its live tools/list put it at 12.0, 1.5 behind Radial MCP's 13.5 on the shared rows, and level with Jira's acli.
• The scoring is uneven. Radial is scored from source, which shows everything it does; Linear from its tool list and docs, which show that a tool exists, not how well it works. Linear's GraphQL API, which is how many agents reach Linear today, has no column here: it is a general API, not an agent surface, and we have not scored it.
• We picked the rows. Three describe features only Radial ships. On the 16 shared rows, Radial CLI scores 13.0 and the nearest official CLI, Jira's acli, 12.0. Linear has no official issue-management CLI to compare.
• Radial is not at parity with itself. The local stdio MCP server lacks the attachment tools, the CLI has no bulk update or notification mark-read, and no surface manages webhooks.

For contrast, the screenshot below shows the local Radial MCP server listing its tools, run offline with no account.

In the screenshot, radial mcp starts over stdio with an initialize request and a tools/list request piped in, filtered through jq. It prints 41 tools, then every tool name, from create_issue, update_issue and list_issues through get_build_rollup, search_build_events, list_cycles and triage_queue.

#A neutral tracker, or a platform with its own agents

This is the structural difference, stated as each side documents it.

Linear runs its own agent and hosts others.

• Linear Agent is "available by default in your workspace". It can "create and update work like issues, projects, milestones and initiatives" (docs).
• Coding sessions (2026-09-24): assign a task to Linear Agent and it writes and tests code in a cloud environment.
• Loops (2026-07-20): "a new way for Linear Agent to take on recurring work for your team", on all plans, using AI credits.
• AI credits: coding sessions and Loops require them; admins can set spend limits.
• Triage Intelligence: Business and Enterprise.
• Third-party agents: "an open platform for third party agents". Apps install with actor=app, can be assigned as a delegate (app:assignable), and must "emit a thought activity within 10 seconds" of a session starting (developer docs). Partners listed include Cursor, OpenAI Codex, Devin, Sentry, Factory and GitHub Copilot.

Radial runs no agent. Your agent, your model, your keys: Radial is the shared state they read and write, through the CLI, MCP or REST. There are no AI features to meter, which is why there are no credits. The trade is real: Radial has no delegate field (the agent becomes the assignee), and no push channel to agents, so an agent learns about new work by polling list_notifications.

If you want the tracker to also be an agent, Linear is built for that. If you want the tracker to stay out of the agent business, Radial is.

#Agent workflow: pick up, update, close

The same four steps in each surface: take the next unassigned issue, mark it started, post proof, close it. Issue creation is left out of every count.

Radial CLI (6 commands, from the CLI source):

radial list --assignee unassigned --status Todo --limit 1 --json
radial claim ENG-42 -s "In Progress"                  # atomic: exits 3 if another agent has it
radial build start ENG-42                             # opens the build the gate records into
radial build gate --gate unit --exec -- pnpm test     # the CLI runs the check and records it
radial comment ENG-42 "Root cause: retry loop never backed off. Fixed in #412."
radial close ENG-42 -m "Fixed in #412"

Radial MCP (4 tool calls): list_issues { "assignee": "unassigned", "status": "Todo", "limit": 1 }, claim_issue { "id": "ENG-42", "status": "In Progress" } (one atomic write), comment, close_issue with a message. Statuses go by name.

Linear MCP (4 tool calls, run live, n=5): list_issues for the next one, save_issue with assignee: "me" and a started state to claim it, 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. We have not timed Radial MCP live, so the two are not a speed comparison. For a reviewer agent that should never write, point it at https://mcp.linear.app/mcp/readonly. Radial has no read-only endpoint; use a key with the read scope.

Linear GraphQL (5 requests, from Linear's public GraphQL schema; the claim race below runs request 3 live). Personal API keys go in the Authorization header.

# 1. Next unassigned, unstarted issue in ENG
query { issues(first: 1, filter: { team: { key: { eq: "ENG" } }, assignee: { null: true }, state: { type: { eq: "unstarted" } } }) { nodes { id identifier } } }
# 2. Who am I, and the team's workflow state ids
query { viewer { id } workflowStates(filter: { team: { key: { eq: "ENG" } } }) { nodes { id name type } } }
# 3. Claim and start
mutation { issueUpdate(id: "ISSUE_ID", input: { assigneeId: "VIEWER_ID", stateId: "STARTED_STATE_ID" }) { success } }
# 4. Proof
mutation { commentCreate(input: { issueId: "ISSUE_ID", body: "Root cause: retry loop never backed off. Fixed in #412." }) { success } }
# 5. Close
mutation { issueUpdate(id: "ISSUE_ID", input: { stateId: "COMPLETED_STATE_ID" }) { success } }

That works well; it also means the agent writes GraphQL, resolves state ids, and parses nested JSON on every task. The alternative is a community CLI such as schpet/linear-cli, which calls itself "agent friendly" and is maintained outside Linear.

#Two agents, one issue: who wins the claim

The chart shows the scripted claim race, n=20 per setup. In a shared checkout, both agents claimed the same task in 20 of 20 trials and one claim was lost silently in 20 of 20. With separate git clones, the second push was rejected in 20 of 20, and the loser then hit a rebase conflict in 20 of 20. The script always takes the first open task, so the 20 trials are one deterministic outcome repeated, not a sample of real collision rates.

We scripted two agents claiming the first open task from a shared TODO.md. In one checkout, 20 of 20 races lost a claim silently (E-BASE-RACE-shared-lost). In separate git clones, git rejected the second push 20 of 20 times and the loser hit a rebase conflict 20 of 20 times (E-BASE-RACE-git-rejected, E-BASE-RACE-git-conflict).

A plain assign behaves like the shared checkout: it is last-write-wins, so both agents get a success. We ran that race against Linear live (L-LIVE-RACE): 20 workers per round, 10 rounds, one fresh issue per round. Linear has no conditional update, so each worker read the issue and, if it was still in Todo, called issueUpdate to assign and start it.

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.

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

#Limits that hit agents

• Requests. Radial allows 120 requests per minute per credential, burst 120, enforced per server instance. Linear allows 2,500 requests per hour on an API key, about 41.7 per minute, and 5,000 per hour per user for OAuth apps. The two are not directly comparable: Radial's counter lives in each server instance's memory, so the effective ceiling depends on how many instances serve your traffic, while Linear counts per key or per user across its service, which is easier to plan against.
• Query cost. Linear caps one GraphQL query at 10,000 complexity points, and each hour at 3,000,000 points on an API key or 2,000,000 per user on an OAuth app. An agent fetching issues with nested comments has to page in smaller chunks.
• Backoff. A Radial 429 carries no Retry-After header yet; the agent picks its own wait.
• Context per session. An MCP client loads the whole tools/list into the agent's context before the first call. Linear's is 101,447 bytes for 60 tools, about 1,690 bytes a tool (L-LIVE-MCP-TOOLS). Radial's hosted list is 21,020 bytes for 45 tools, about 470 bytes a tool (R-LIVE-MCP-TOOLS), and its local stdio server returns 41 tool schemas in 12,923 bytes (E-RAD-STDIO-toolslist-bytes). Fewer bytes is not more capability; the coverage table above is what each list can do.

#Hidden costs

Download this table as CSV.

#Enterprise practical setup

Download this table as CSV.

#Where Radial loses or ties

• No free tier. Linear Free costs $0 with MCP and the API.
• No delegate field. A claim makes the agent the assignee, so the human owner disappears from the issue.
• No push to agents. Linear sends agent-session webhooks; Radial agents poll.
• No webhooks API. Linear admins and admin-scoped apps create webhooks over the API; Radial configures them in the settings UI only.
• No SAML SSO or SCIM. Linear has both on Enterprise.
• No read-only MCP endpoint, and no smaller toolset: every session on the hosted server loads all 45 tool schemas.
• No presence indicators or multiplayer editing of descriptions, and a smaller integration ecosystem.
• Polish. Linear set the bar for speed and keyboard craft. Radial is built to it, not past it.

#Moving from Linear

Linear's built-in export is CSV. radial import --from linear reads Linear's GraphQL JSON instead, so export through the API.

1. Fetch issues with a personal API key. Page with after until hasNextPage is false; if Linear rejects a page for complexity (10,000 points per query), lower first.

curl -s https://api.linear.app/graphql \
  -H "Authorization: $LINEAR_API_KEY" -H "Content-Type: application/json" \
  -d '{"query":"query($after:String){ issues(first:50, after:$after, filter:{team:{key:{eq:\"ENG\"}}}) { pageInfo { hasNextPage endCursor } nodes { id identifier title description priority estimate dueDate createdAt updatedAt state { name type } team { key } assignee { email } project { name } labels { nodes { name } } parent { id } relations { nodes { type relatedIssue { id } } } comments { nodes { body createdAt user { email } } } } } }","variables":{"after":null}}' \
  > page-1.json
jq -s '{issues: map(.data.issues.nodes) | add}' page-*.json > export.json

1. Dry-run. Nothing is written; you get counts and up to ten warnings.

radial import --from linear export.json --dry-run

1. Import, then verify:

radial import --from linear export.json
cursor=""; total=0                     # --all adds archived issues; it does not fetch every page
while :; do
  page=$(radial list --team ENG --all --limit 100 --json ${cursor:+--cursor "$cursor"})
  total=$((total + $(jq '.issues | length' <<<"$page")))
  cursor=$(jq -r '.nextCursor // empty' <<<"$page")
  [ -z "$cursor" ] && break
done
echo "$total issues"                   # compare with the dry-run count
radial show ENG-1

What comes across from Linear: titles, descriptions (markdown), statuses (matched by name, then by category), priorities, assignees (matched by email to a workspace member), labels, projects, estimates, due dates, parent issues, relations (blocks, related, duplicate), comments with their original timestamps, created timestamps, and updated timestamps (except on sub-issues, where linking the parent sets the updated time to the import time).

What does not: attachments, cycles, custom fields, change history, watchers, and comment authors (imported comments are posted under the importing user's name). An assignee email with no matching member is left unassigned, with a warning. The Linear migration guide covers the details.

#What you can verify before you buy

These come from Radial's terms, privacy policy and source code. We do not publish an uptime figure, a status page or a support response time yet, so none is claimed here.

• Price and billing: $50 per user per year, billed annually. No monthly plan, no free tier, no trial.
• Who counts as a user: every human member of the workspace, whatever their role. Agent members never count.
• Seats mid-term: adding a person is invoiced at once, prorated. Removing one is not refunded pro rata for the rest of the term.
• Cancelling: any time, in the billing portal or by emailing support@radial.build; it takes effect at the end of the term. Payments are non-refundable except where the law requires. Renewal is at the then-current price.
• If a subscription lapses: the workspace becomes read-only after a grace period, and the data stays readable and exportable.
• Export: radial export --format json returns every issue, every comment, and the workspace's statuses, labels, cycles and members, plus its teams and projects that are not archived. --format csv returns issues only. Attachment files, issue relations, file comments, activity history, and build records and sessions are not in that export today; attachments come per issue through radial attachments or the API, and builds through radial build export <ISSUE>.
• Where data lives: processed and stored in the United States, primarily in an AWS US region.
• Security basics: TLS in transit, tenant isolation by Postgres row-level security, API keys stored as SHA-256 hashes, Git provider tokens and webhook secrets encrypted with AES-256-GCM.
• API limit: 120 requests per minute per credential, burst 120, enforced per server instance.
• Support: support@radial.build. Radial is operated by BrainGrid AI, Inc.

#When to pick Linear instead

• You want a free tier, or you are one person trying things out.
• You need SAML, SCIM or a 90-day audit log.
• You want the tracker to run its own agent: coding sessions, Loops, Triage Intelligence.
• Your agents should be delegates, with the human staying the owner, and should be woken by webhooks rather than polling.
• You value Linear's integrations and multiplayer editing more than a CLI.

If you are weighing more than Radial, the best Linear alternative ranks GitHub Issues, Plane, Shortcut and Jira as well, with costs for teams of 5 to 200 people. If you are choosing between Linear and Jira, read Jira vs Linear for AI coding agents: MCP coverage, CLIs, credits, rate limits and the claim race, side by side.

#Methodology

Interim benchmark, run 2026-11-02 against Radial commit 9126321 (CLI 1.3.0), git 2.47.3 and Claude Code 2.1.306, plus a live phase against Linear's MCP server (1.0.2) and API and Radial's hosted MCP server.

• Live Linear: tools/list against mcp.linear.app/mcp (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 is still compared from docs; its live runs are pending.
• Live Radial: tools/list against mcp.radial.build/mcp (R-LIVE-MCP-TOOLS). The atomic claim is live in production; its evidence is the race tests in Radial's unit and integration suites, not a live multi-identity run (R-CLAIM-ATOMIC).
• Claim race, no tracker: two scripted agents, one shared TODO.md, both picking the first open task, n=20 per setup. Evidence: E-BASE-RACE-shared-same, E-BASE-RACE-shared-lost, E-BASE-RACE-git-rejected, E-BASE-RACE-git-conflict.
• Raw data: every evidence id links to its raw file under benchmarks/runs/2026-11-02; the full index, with JSON paths and the command behind each number, is evidence.json.
• Coverage: 19 rows. Linear scored from its live tool list plus its docs and changelog, Jira from Atlassian's docs (read on Nov 2, 2026), Radial from source. Radial counts measured from the code: the run counted 44 hosted and 41 stdio tools (E-RAD-MCP-count, E-RAD-STDIO-count), which is 45 hosted tools and 42 stdio tools with claim_issue added since, 12,923-byte tools/list (E-RAD-STDIO-toolslist-bytes).
• Not measured yet: a live Radial task flow and a live multi-identity Radial claim race. Nothing here claims Radial is faster per task than Linear.

#FAQ

#Can I use an issue tracker like Linear as the work queue that orchestrates my Claude Code agents?

Yes when one orchestrator assigns each issue to one agent: Linear's delegate model and agent sessions are built for that. When several agents pull their own work, Linear has no conditional update, so two agents can both claim one issue: in our live race, more than one worker was told "claimed" in 10 of 10 rounds. Radial's radial claim (MCP claim_issue) is one conditional write with exactly one winner, and the loser exits 3 and takes the next issue. Radial has no push to agents and no claim lease yet.

#What is a good Linear alternative that works well with Claude Code and Codex?

Radial: a first-party radial CLI with --json output, a hosted MCP server with 45 tools in 21,020 bytes, an atomic claim, rd-* skills for Claude Code and Codex, and session hooks for both, at $50 per user per year with agents not billed and no credits. Linear has no first-party issue CLI (its official linear-release CLI tracks releases), and its own agent's coding sessions and Loops draw AI credits. See also Jira vs Linear for AI coding agents.

#Does Linear have an official CLI?

Linear has no official issue-management CLI. It ships linear-release for tracking releases and a CLI Importer for moving data in. Agents work Linear issues through the hosted MCP server, the GraphQL API, or community CLIs such as schpet/linear-cli.

#How many tools does the Linear MCP server have?

1. We called tools/list on mcp.linear.app/mcp (server 1.0.2) on 2026-11-02 and got 60 tools in a 101,447-byte response. Linear's docs publish no list; they describe tools "for finding, creating, and updating objects in Linear like issues, projects, and comments". Radial's hosted MCP server has 45 tools in 21,020 bytes.

#Can two agents claim the same Linear issue?

Yes. Linear has no conditional update, so a claim is a read and then an issueUpdate. In our live race of 20 workers over 10 rounds, more than one worker was told it had the issue 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). Radial's radial claim (MCP claim_issue, REST POST /v1/issues/{id}/claim) is one conditional write: one winner, and a 409 for everyone else.

#Do coding agents cost extra in Linear or Radial?

Neither bills agents as seats. Linear's own agent work, coding sessions and Loops, draws AI credits. Radial charges no credits for anything: $50 per user per year for the people, flat.

#Is Radial cheaper than Linear?

At list price, yes on paid plans: $50 per user per year against $120 (Basic) or $192 (Business), verified on Nov 2, 2026. For 10 people and 20 agents that is $500 against $1,200 or $1,920; for 25 people and 50 agents, $1,250 against $3,000 or $4,800. Linear Free is cheaper than both, at $0 for up to 250 issues and 2 teams.

#How much do Linear AI credits cost?

Linear sells AI credits prepaid, with a $10 minimum top-up, and they expire 12 months after purchase. Only Linear Agent coding sessions and Loops draw them: a coding session costs its model tokens at the provider's published rates plus $0.25 per 20-minute sandbox block, and a loop run with no coding session costs $0.07 to $0.20. Your own agents calling Linear's MCP server or API draw no credits, per the pages we read.

#Can I move from Linear to Radial?

Yes. Export issues as JSON through Linear's GraphQL API (the built-in export is CSV), then run radial import --from linear export.json --dry-run to preview and the same command without --dry-run to import. Issues, statuses, priorities, assignees, labels, projects, estimates, parents, relations, comments and timestamps come across; attachments, cycles, custom fields, history and comment authors do not.

#Does Radial have its own AI agent like Linear Agent?

No. Radial runs no agent and ships no AI features. Claude Code, Codex or any MCP client does the work through the radial CLI, the MCP server or the REST API.

#Is Radial the same as radial.com?

No. Radial at radial.build is an issue tracker for software teams and their coding agents, unrelated to other companies named Radial.