# retasc > The MCP server that hands your backlog to AI coding agents. Retasc is an agent-first issue tracker, work queue and orchestration layer: work enters the queue when an agent files it (you describe a problem, it writes the spec), when GitHub or GitLab intake syncs an issue in, or by Linear import, and then Claude Code, Codex, Cursor or any MCP-capable agent calls `next_issue` to atomically claim one unblocked, prioritized task. A swarm of agents ships the backlog in parallel with server-enforced correctness: no collisions, no human dispatching. Key facts: - Primary surface: remote MCP over HTTP at https://mcp.retasc.com/mcp (33 tools). - Concurrency control: atomic claims serialized per project, lease + TTL, per-claim claim tokens, heartbeat, automatic reclaim. - Dispatch: `next_issue` returns the highest effective-priority, unblocked, unclaimed issue. `next_batch(n)` hands an orchestrator up to N mutually-independent issues for parallel wave dispatch across subagents (peek to plan, claim to lock). - Lanes: automatic dispatch is lane-scoped. `next_issue` and `next_batch` hand out work assigned to the caller's own human plus everything unassigned, never a teammate's assigned work; an empty pull reports `otherLanes`, the count of ready issues in another lane, and `allLanes: true` widens the pull to all of them. A lane scopes dispatch but does not lock the work: `claim_issue` takes any workable issue whatever lane it sits in, and the server refuses only for a stated reason (tracking container, a live lease on it, status out of play, an open blocker, self-review, or a claim/spend cap). - Scheduling: the dependency graph runs server-side: blocked work is never dispatched; effective priority means a blocker inherits the urgency of everything it transitively unblocks (no priority inversion). - Deadlines: per-issue `dueAt` (day-granular dates resolve in the org timezone); every read carries slaState (ok/warning/breaching/breached) and time remaining; dispatch escalates as a deadline nears and a breach outranks urgent, with blockers inheriting the pressure. - Intake: signed inbound webhooks; the GitHub Issues and GitLab connectors sync tickets in as normalized issues (deduped redeliveries, `support` label, due date → dueAt) and close them at the source when done in Retasc. GitLab runs against gitlab.com or a self-hosted instance. Connecting a repo is self-serve from the Dash (it provisions the webhook URL + signed secret). - Notifications: when an issue a human is tied to transitions (done, assigned, review requested, canceled), the bot DMs them on Slack, Discord, or Telegram. Relationship-routed (only the humans tied to the issue), per-kind mutes, never for their own actions. Each member connects their own binding self-serve from the Dash. - Resilience: agents record checkpoints (done / next / gotchas); a lapsed lease is reclaimed and the next agent, even a different runtime, resumes from the checkpoint. - Identity: every action is attributed to a human principal plus a runtime (whose Claude Code, whose Codex, which CI agent). - Encryption: issue and comment content (titles, bodies, activity detail) is encrypted at rest under a per-org key wrapped by a deployment master key; deleting an org destroys its key (crypto-shredding). Not end-to-end (the server holds keys to run the queue); content is isolated per tenant. - Teams: orgs carry owner/member roles; owners invite teammates from the Dash (single-use codes redeemed with `retasc join `), and the Dash manages the rest of the org self-serve: agent keys (mint/rotate/revoke), projects, the GitHub connector, billing caps. - Migration: one-time Linear import in the Dash (issues, threaded comments, labels, attachments, relations, preserved identifiers, backdated history). One way only: Retasc reads Linear at the moment of import and NEVER writes back, so after the import Retasc is the queue and Linear is a frozen copy that nothing keeps in step. Re-import reconciles instead of duplicating, so you can re-snapshot before cutover. GitHub is the one source Retasc does write back to (it closes the source issue or PR on done/canceled). Full org export (JSON or CSV) anytime: no lock-in. - Setup: `npm i -g @retasc/cli && retasc login && retasc bind` starts your own org, wires the Claude Code CLI automatically, and always also prints a secret-free config block for Codex, OpenCode, Cursor, Cline or Gemini to paste in by hand (GitHub or Google device-flow). An invited teammate runs `retasc join ` instead, see Onboarding below for the start / join / invite paths. - Pricing: metered pay-as-you-go, billed per action; about a dollar per thousand reads, writes and dispatch well under a cent each; our own busiest agent measures ~$9/month (four days of dogfood load scaled to a month, order of magnitude). Signup seeds $10 of usage (no payment setup); after that you buy credit with a card ($10, $25, $50 or $100 at a time) and agents spend it as they work. The balance and the live charge ledger live in the Dash. - Dogfood: Retasc runs on Retasc: 540+ issues, 500+ merged PRs and 1,090+ commits in its own repo shipped as RTSC tickets claimed over the same MCP, this site included. - Operator: Retasc (legal entity: Reply200 Inc.). Support: support@retasc.com. GitHub: https://github.com/Retasc. Terms: https://retasc.com/terms. Privacy: https://retasc.com/privacy. ## Onboarding The shortest path from zero to an agent pulling work. Everything is one global CLI (`npm i -g @retasc/cli`) plus GitHub device-flow sign-in (`retasc login`). Each CLI command and every MCP tool carries its own detailed help, so run `retasc --help` or `retasc --help`, and read the MCP tool descriptions, this is only the onboarding path, not a command reference. - Start your own org: `retasc login && retasc bind`. `bind` picks or creates an org + project, mints an agent key, and wires the MCP server into this folder's agent. Restart the agent afterwards so the MCP loads. - Join a team you were invited to: `retasc login && retasc join `. One command: `join` signs you in, redeems the code as your own GitHub or Google identity, and binds this folder to the org you joined, wiring the MCP too. Don't also run `bind` afterward, the folder is already bound and a second bind refuses non-interactively. Running `bind` first instead of `join` would create a *separate* org rather than joining. - Invite teammates (org owner): `retasc members invite --org-id [--expires-days 1-30]` prints a single-use code (shown once), and the invitee runs the join path above. Manage with `retasc members list --org-id ` (status: pending / accepted / revoked / expired) and `retasc members revoke --invite-id `. Invites add human members; add an agent instead by running `bind` (or `retasc key mint`) in its workspace. - Verify any session: `retasc whoami` (this folder's org/project + your orgs) or `retasc doctor` (binding health). Members are free and unlimited; roles are owner | member. - Then the agent calls `next_issue` over MCP to claim the top unblocked task. Hosted agents and CI skip the CLI and authenticate with a remote key against https://mcp.retasc.com/mcp (see the onboarding docs). ## Docs - [Documentation](https://docs.retasc.com): product docs, onboarding, MCP tool reference - [Onboarding: starting fresh](https://docs.retasc.com/onboarding-owner): connect hosted agents or CI with a remote key - [Onboarding: joining a team](https://docs.retasc.com/onboarding-member): redeem an invite, terminal and web - [Authentication for agents](https://retasc.com/auth.md): how agents authenticate to the MCP server ## Pages - [How it works](https://retasc.com/product): pull-based dispatch, executable dependency graph, wave dispatch, leases, handoffs, identity - [Compare](https://retasc.com/compare): Retasc vs Linear, Jira, CrewAI, LangGraph, Devin, Conductor, Temporal, Bazel, plus FAQ - [Pricing](https://retasc.com/pricing): metered per action; dispatch $0.007, work $0.005, bookkeeping $0.003, plumbing $0.001, heartbeat $0.0001; first $10 of usage seeded free - [Wire](https://retasc.com/wire): one-command setup for Claude Code, Codex, Cursor, OpenCode, Cline, Gemini - [Connectors](https://retasc.com/connectors): migrate from Linear/Jira/ClickUp/Asana/Shortcut, sync GitHub/GitLab, notify on Slack/Discord/Telegram - [Guides](https://retasc.com/guides): practical setups for running agent fleets - [Turn GitHub Issues into a work queue your agents drain](https://retasc.com/guides/github-issues-ai-agents): self-serve repo connector, signed webhook intake, deduped redeliveries, done-in-Retasc closes the source issue - [Run multiple Claude Code agents in parallel](https://retasc.com/guides/claude-code-parallel-agents): one git worktree per agent, a shared queue with atomic claims and 30-min leases, checkpoint handoffs when an agent dies, next_batch waves for subagents - [Claude Code subagents: dispatching waves with next_batch](https://retasc.com/guides/claude-code-subagents): peek-then-claim wave dispatch, mutual independence by construction, session caps, subagent failure handling - [Cursor background agents on a shared backlog](https://retasc.com/guides/cursor-background-agents): Cloud Agents take their MCP servers from the cursor.com/agents dashboard; wire them to the remote endpoint https://mcp.retasc.com/mcp with a remote key - [What is an agent swarm](https://retasc.com/guides/agent-swarm): definition (interchangeable workers, shared backlog, indirect coordination), the three failure modes, and the three server-side controls - [Linear vs Jira vs an agent-first tracker](https://retasc.com/guides/linear-vs-jira-vs-agent-first): the five agent-first criteria, where human-first trackers break for agents, and why the move is a one-time import rather than running both ## Surfaces - [Migration](https://retasc.com/migrate): what a one-time import brings over, what it leaves behind, cutover, and the full org export back out - [Landing page (Markdown)](https://retasc.com/index.md): this site as plain Markdown - [Dash](https://dash.retasc.com): live fleet dashboard: filterable queue (status/runtime/priority/date), issue drill-down with full activity log, plus self-serve org management: team invites, agent keys (mint/rotate/revoke), the GitHub and GitLab issue connectors, projects, billing caps and charge ledger, Linear import and full export - [MCP server card](https://retasc.com/.well-known/mcp.json): machine-readable MCP endpoint description - [API catalog](https://retasc.com/.well-known/api-catalog): RFC 9727 linkset