We have been looking at indie and technical products in the AI stack that solve a problem we actually hit. One stood out: Retasc, an issue tracker that lets Claude Code, Codex, Cursor, and other coding agents pull from the same backlog without colliding.
The interesting part is a server-side coordination layer. The queue decides what is unblocked, claims it atomically, leases it, and rejects writes from a dead agent that wakes up late. Markdown conventions and Linear’s MCP CRUD do not do that.
Quick answer
One coding agent can live in GitHub Issues or Linear. Five agents on the same repo need a dispatcher that is not a human. Retasc exposes the queue over MCP. An agent calls next_issue(); the server picks the highest effective-priority unblocked issue, claims it in one transaction, and hands back a 30-minute lease, a fencing token, and a branch name. Two callers in the same second get two different issues. Cipher’s cutover: keep Linear until the human is the bottleneck; move to a server-side queue once you want more than one agent draining the same backlog unattended.
Best for: teams already running Claude Code, Codex, or Cursor who want a fleet on one backlog. Honest limit: Retasc does not make tangled architecture work parallel. A type-system rewrite still wants one agent and a human. Cipher has not audited Retasc’s internals. Numbers below are from public product pages as of 6 September 2026, phrased as Retasc reports them.
Cipher Projects is an Australian-led AI engineering studio. We already split Cursor as the editing surface and Claude Code as the autonomous worker. The missing piece, once you want more than one worker, is the queue.
Last updated: 6 September 2026.
What happens when you run five AI coding agents on one backlog?
They collide. Two sessions read the same GitHub issue, the same Linear ticket, or the same TODO.md, and both start the same fix. They also share one checkout, so the second commit lands on the first agent’s branch. A laptop sleeps and the work is stranded with no checkpoint. A blocked ticket still looks “next” because the tracker only stores a blocked label; it does not refuse to dispatch it.
At one agent, a normal tracker is enough. At five, the human becomes the dispatcher:
human
├── agent
├── agent
├── agent
├── agent
└── agentThe person who used to write code now assigns tickets, watches for dead sessions, and tells agent B not to touch what agent A is holding. That job does not scale to 50 agents. You need infrastructure for scheduling, isolation, identity, leases, and recovery. Retasc is built for that layer.
Claude Code’s own agent teams can share a task list inside one session. Anthropic’s docs are clear that worktrees isolate files, while teams coordinate work. The list lives under ~/.claude/tasks/, dies with the session, and cannot take a Codex agent on another machine. Reach for a server when the fleet has to outlive the session.
What is Retasc?
Retasc is an issue tracker whose MCP server is the product. The dashboard is a window onto the queue: leases ticking down, who holds what, billing caps. Agents connect over HTTP to https://mcp.retasc.com/mcp. The documented bind command is:
npx @retasc/cli@latest bindThat signs you in, mints an agent key, and wires the MCP server into the current folder. Retasc lists Claude Code, Codex, Cursor, OpenCode, Cline, Gemini, and CI runners as clients of the same queue. Handoffs cross runtimes: Codex can resume a checkpoint Claude Code left.
Retasc says it runs on Retasc. As of this writing the homepage reports 170+ issues shipped by the fleet, 160+ PRs merged, and 400+ commits under the same queue. Those are the company’s own counts, not an independent audit.
How does next_issue stop two agents claiming the same work?
The claim is one server transaction. An agent does not read the backlog and then take a ticket. It calls next_issue(). The server walks the dependency graph, picks the highest effective-priority unblocked unclaimed issue from that agent’s lane (or the shared pool), and claims the row it returns. Claims are serialized per project. Four agents calling in the same second get four different issues.
Agent A → next_issue() Agent B → next_issue()
\ /
\ /
server transaction
/ \
Issue 27 → A Issue 28 → BThe claim carries a token only its holder can heartbeat, checkpoint, or release with. Closing is fenced to the holding session. A stale agent’s writes bounce with CLAIM_LOST. That is closer to a fencing token than to a lock file your agents are supposed to honour.
Linear’s MCP, on Retasc’s own compare page, is CRUD on a tracker built for humans clicking. An agent can read and write issues. Nothing stops two agents taking the same one, and the dependency graph is decoration. Retasc runs the orchestration on the server. We have not verified Linear’s internals; we are repeating Retasc’s published distinction because it matches the failure mode we see with “just connect Linear MCP.”
next_batch(n) does the same thing for a wave. The server peeks issues that are unblocked and mutually independent, then can claim the wave atomically, each issue with its own token and branch. A batch defaults to five issues and caps at 25 per call. A session can hold seven claims at once, so an orchestrator cannot silently lock the whole backlog. That is the documented ceiling, not a Cipher benchmark.
What happens when an agent dies mid-task?
The lease expires and another agent resumes from the checkpoint. A claim is not permanent. The default lease is 30 minutes, renewed by heartbeat and by checkpointing. The local proxy installed by bind sends a heartbeat every 10 minutes while the session lives. Kill the terminal and the heartbeats stop. A server-side sweeper reclaims a lapsed lease within about five minutes and returns the issue to the pool.
Agent A claims → works → heartbeat
X crashes
lease expires
sweeper returns the issue
Agent B (maybe Codex) resumes from checkpointThe checkpoint is a note the working agent updates at milestones: what is done, what is next, the gotchas. The next holder, even a different runtime, continues from that log instead of starting from zero. If the original agent reconnects and tries to write, its token is no longer valid. CLAIM_LOST is the fence.
This is why a markdown lock does not survive a closed laptop. A lock needs someone to unlock it. A lease only needs a clock.
How does the dependency graph become the scheduler?
Blocked is computed when an agent asks, not stored as a stale label. If A blocks B and B blocks C, B is not dispatched until A is done. When A closes, B becomes eligible and C stays blocked. The ready frontier is the set of issues an agent is allowed to see.
Priority follows that graph. Retasc computes effective_priority(X) as the strongest priority among X and everything X transitively unblocks, then floors it by deadlines. A low-priority chore that blocks an urgent feature inherits the urgency. Agents do not pick “highest ticket on the board.” They get the next issue on the critical path.
Deadlines climb the same way. Past 75% of the time to dueAt an issue ranks High; past 90% Urgent; a breach outranks both. Blockers inherit the pressure. Every read carries an slaState (ok / warning / breaching / breached). Again: this is Retasc’s published dispatch rule, not a Cipher measurement of how often it fires in the wild.
Review is optional work on the same queue. Finish into review and the author’s lease frees, dependents stay blocked, and a different human principal pulls the review. The gate compares humans, not agent sessions. Another runtime under the same person does not count as a second reviewer. Name nobody and finishing marks the issue done, so a one-person org is not stuck.
How do git worktrees fit with the queue?
Retasc handles logical isolation. Git worktrees handle filesystem isolation. One agent, one issue, one branch, one worktree.
Git repository
│
┌──────────┼──────────┐
↓ ↓ ↓
Agent A Agent B Agent C
worktree worktree worktree
│ │ │
branch A branch B branch CThe branch name arrives with the claim, computed server-side, so every runtime lands the same issue on the same branch. retasc claim --shell claims the next unblocked issue, creates the worktree, and drops you into a subshell inside it. Isolation cannot be retrofitted: once two agents have edits in a shared checkout, there is no clean move.
Claude Code’s claude --worktree flag is the other half of that story. It creates a worktree and then refuses to let the agent write into the main checkout. It does not know what either session is working on, so nothing stops both from picking the same issue, and nothing survives the laptop closing. Use --worktree when you are driving two sessions by hand. Take the queue when the fleet has to share a backlog across sessions and runtimes.
Retasc also installs a commit gate so every commit names its issue (RTSC-41) or declares [no-issue]. With several agents committing at once, that stops being optional. retasc tidy --prune reaps worktrees whose issues are done and merged.
Who is actually responsible for the agent?
A human principal plus a runtime. Retasc binds identity to the person who authenticated (GitHub, in the privacy policy) rather than trusting whatever name the agent claims. Every action is attributed to principal + runtime. Suspend the human and every key under them stops authenticating; their claims lapse back to the queue. Agent keys are scoped to one organisation.
The privacy policy (effective 19 July 2026) says data is encrypted in transit and at rest, organisations are isolated, and content is not used to train models. Field-level encryption is described as XChaCha20-Poly1305 under an organisation-specific key. Published subprocessors are Convex (backend/database), Cloudflare (site + MCP proxy), GitHub (auth), Xenarch (payment settlement on Base/USDC), and Google Analytics on the website and dashboard. We are quoting the policy, not certifying the implementation.
What does Retasc cost?
It is metered per action, not per seat. Signup seeds $10 of usage with no card. After that you buy credit. Retasc’s published rate card as of 6 September 2026:
| Class | Price | Examples |
|---|---|---|
| Dispatch | $0.007 / action | next_issue, next_batch, claim_issue, add_relation |
| Work | $0.005 / action | save_issue, checkpoint, save_comment |
| Bookkeeping | $0.003 / action | status, priority, title edits |
| Plumbing | $0.001 / action | reads, release, whoami. Heartbeat is $0.0001 |
Retasc’s own workload example, not an independent benchmark: about $8.93/month for one busy agent (250–300 issues, each claimed and checkpointed more than once), and about $24.56/month for five agents under their stated mix of two busy and three quieter. They compare that with Linear seat list prices. Re-check retasc.com/pricing before you budget; meter products change.
You can import a backlog from Jira, Linear, Shortcut, Asana, or ClickUp in one pass. GitHub and GitLab issues sync as claimable queue items and can close back at the source. Notifications go to Slack, Telegram, Discord, or email, routed to the humans tied to the issue, not for your own actions. Linear import is one-way: Retasc does not write back to Linear after the snapshot.
When should you actually use Retasc?
When work decomposes into independent, well-specified chunks an agent can do unattended. A pile of bugs, tests, docs, and small isolated features is the native shape. “Redesign the architecture” still wants a human. Retasc’s own FAQ says the same.
Cipher’s cutover from delivery work:
- One agent, one human watching: GitHub Issues or Linear is enough. Do not add a queue yet.
- Two or three sessions on one repo, same afternoon: Claude Code agent teams or
claude --worktreemay be enough. The task list dies with the session. - A fleet that outlives the session, mixed runtimes, or a human who has become the dispatcher: a server-side queue with atomic claims and leases. Retasc is the product we would trial first for that job, starting with the $10 of seeded credit and two agents, not fifty.
Expect PR review to become the bottleneck. Agents produce. You decide what merges. Start with two or three agents and raise the count only while review keeps up.
This sits next to the gap we already wrote about: a Claude workflow is not a production agent. Identity, connectors, and audit still have to live on your platform. Retasc is the backlog side of that problem, not a substitute for SSO and a sandbox.
What else is worth looking at?
Retasc is the most technically significant product we looked at in this set. It answers a problem AI created: what happens when the number of developers becomes the number of coding agents. The others below are not the same category. They are indie and technical products we found interesting for different reasons.
| Product | Problem | Interesting bit | Best for |
|---|---|---|---|
| Retasc | Agents collide on one backlog | MCP + atomic claims + leases + graph dispatch | A mixed fleet of coding agents |
| IsItUp.now | Is the site actually up? | Distributed checks plus a CLI with real exit codes | Fast diagnostics, not another status-page SaaS |
| Speakmac | Cloud transcription subscriptions | On-device speech on the Mac | Private dictation you buy once |
| Piqo | Analytics that stop at pageviews | Sub-1KB cookieless tracker + Stripe/Paddle/Polar revenue | Which traffic actually made money |
| VibeCodingList | Building got cheap; useful feedback did not | A marketplace for targeted reviews, with reputation and payouts | Getting a specific question answered on a live app |
| Vanpelt Studio | Long-form video: you find out you are missing shots on day 12 | Local-first story spine checked against the footage you actually shot | Solo long-form, before you sit in the editor |
| InferenceSaver / Treg | Agent tooling APIs need one key, one bill | SpyFu and Serpstat through a unified gateway, then inference on top | Building a competitor table from SEO APIs |
IsItUp.now
IsItUp.now is a website and network diagnostic: status, DNS, SSL, ports, headers, IP lookup, bulk domain checks, status badges, and a CLI. The founder describes the app layer as Phoenix / Elixir and the checker nodes as Go, distributed across locations. We could not independently confirm that stack from the public marketing pages, so treat the Elixir/Go split as founder-described until you verify it.
The CLI shape is the part we like. isitup check example.com with --json, --quiet, and --timeout, and exit codes that mean something in CI: 0 everything up, 1 at least one domain down, 2 the check itself failed. That is a tool, not a dashboard with a ping.
Speakmac
Speakmac is on-device voice dictation. Audio does not leave the machine. No subscription. $29 one-time for one Mac; a Windows licence is listed at $39 for two PCs, with the Windows build still on a waitlist as of this writing. Meeting mode records locally with speaker labels. 25 languages by default. macOS 13+, Apple Silicon and Intel.
The maker, JD, says he built it because he was paying $12 a month for transcription, more than his ChatGPT subscription. The architecture is the proposition: microphone to a local speech model, not microphone to a cloud API. If you dictate into Cursor or Claude, that is the privacy difference that matters.
Piqo Analytics
Piqo is privacy-first web analytics that tries to answer which traffic made money. Connect Stripe, Paddle, or Polar once; payments stitch back to the visitor. The tracker is under 1KB, cookieless, with hashed IDs that rotate daily. It also treats AI-assistant traffic as its own channel, which is the measurement we actually want next to Google Search Console.
The data model is the interesting part, not exotic infrastructure:
visitor → session → source → action → signup → payment → revenueMost analytics stops at the session. Piqo’s public pitch is that Top sources should read in dollars. Docs cover a long list of installs, including Next.js, Astro, Django, Laravel, WordPress, Shopify, Webflow, Framer, Wix, Bubble, Lovable, v0, Replit, and Bolt. We have not run Piqo in production; the claim to verify on a trial is whether Stripe stitching survives adblockers and last-touch mess the way the homepage implies.
VibeCodingList
VibeCodingList starts from a thesis we already believe: AI made building cheap, and useful human feedback got scarce. Builders submit a live project, ask one specific question, and mark replies Helpful or High Impact. Contributors review, build reputation, and can earn cash through reward pools and paid Feedback Missions. There is a free AI review path as well.
They also keep a tools directory of coding assistants, app builders, frameworks, and deploy platforms. The marketplace is the product; the directory is how people find it. If you have ever posted a launch into the void and received “looks cool,” this is the structured version of that loop.
Vanpelt Studio
Vanpelt Studio is a local-first desktop copilot for long-form video. You still cut in DaVinci Resolve or whatever you already use. The job it takes is the one that burns weeks when you are the writer, assistant editor, and story editor: write the list, drop the card in, see which beats you actually have.
Cipher uses it to make videos. The useful loop is: a story spine (beats, script, shot list) checked against local transcription of the footage, the same evening as the shoot, while a pickup is still twenty minutes. Raw video and audio stay on the machine. What can leave is text you could read yourself, sent to a model you picked: Claude or ChatGPT subscription, your own Anthropic or OpenAI key, OpenRouter open models, or the AI bundled with Studio.
Published pricing as of this writing: $29/month with AI included, $12/month if you bring your own model, a founding lifetime seat at $89. macOS and Windows. Built for 8, 15, and 30-minute videos, not Shorts. The claim to verify is whether “do I have the video?” lands before you spend 20 hours in the timeline. For us, that is the reason it is in the stack.
InferenceSaver and Treg
InferenceSaver’s Treg write-up is a GTM engineering case, not a model-arena. Treg is a third-party unified API gateway for agent tooling (they call it an OpenRouter for tools; the product lives at treg.to). One key, one bill, many endpoints. InferenceSaver used SpyFu and Serpstat through it, then ran analysis on their own inference layer.
They report a specific test: $0.95 of promotional credit turned a noisy 312-row competitor table into 250 classified records and 250-plus ranked keywords, stored in Twenty. The pipeline they describe is Treg for market data, Buzz CLI for routing, Twenty for storage, and InferenceSaver for the model calls. Those are InferenceSaver’s own numbers and architecture, not a Cipher audit.
The interesting idea is billing shape. Instead of five $5 minimums on five SEO APIs, they paid per result through one gateway ($0.0002 per SpyFu competitor result, $0.0005 per Serpstat keyword, on their published card) and kept inference as a separate layer.
FAQ
Is Retasc a Linear or Jira replacement? For a human clicking tickets, not really, and you can import from those tools. For a fleet of coding agents, Linear stores work and Retasc dispatches it. If your agents are not the ones pulling the queue, you do not need Retasc yet.
Can Claude Code, Codex, and Cursor share one backlog? Yes, on Retasc’s documented design. The queue is a remote MCP server. A Codex agent can resume a checkpoint a Claude Code agent left. We have not run that handoff ourselves.
Does this replace git worktrees? No. Worktrees isolate the filesystem. The queue isolates the work. You want both: one issue, one branch, one worktree, one claim.
What if we already use Claude Code agent teams? Keep them for an afternoon’s work inside one session. Reach for a server when the fleet has to outlive that session, join from another machine, or hand off across runtimes.
How much does a small fleet cost? Retasc’s own example is about $9/month for one busy agent and about $25/month for five under their workload assumptions, after $10 of free credit. Verify the live rate card. Model spend is still the larger bill; the queue is a coordination line item.
Who helps wire this into a real delivery team? Cipher Projects is an AI engineering studio. We help teams adopt Cursor, Claude Code, and the coordination layer around them: where each tool fits, how to gate autonomous runs, and how to keep review as the bottleneck instead of collisions. Australian-led, with delivery across Australia and Vietnam. We are not affiliated with Retasc.
Related: Claude Code vs Cursor (2026) · OpenAI Codex vs Claude Code · Claude workflow vs production agent · Applied AI Engineering
If you are already running two coding agents on one repo and the human is the person who says who goes next, try the queue. npx @retasc/cli@latest bind is the documented start, and the first $10 does not need a card.