Claudexor Routes Coding-Agent Quotas

Claudexor is razzant’s MIT-licensed, local-first control plane for running Claude Code, Anthropic’s coding agent, Codex CLI, OpenAI’s command-line coding agent, Cursor CLI, and other adapters behind one interface. It deals with a very practical annoyance: paid coding-agent subscriptions run out at different times, while each harness keeps its own sessions, context, and review flow. The useful takeaway is not “add more agents”; it is “make routing auditable before routing gets clever.” For Cursor, Anysphere’s AI code editor, this matters less as a cursor skills marketplace story than as a reminder that Cursor skills need review boundaries when agents can swap lanes.

See the control plane, not just the quota trick

Quota-aware routing is a way to choose an agent account or harness based on live limits, cost facts, and task type instead of manually switching tools when one session stops working.

That is the headline feature people noticed. Claudexor’s README describes credential profiles for multiple Claude and Codex subscriptions, with isolated logins and live subscription-quota tracking. When a vendor returns a typed limit, the project can rotate a spent account out of the way under an opt-in policy.

The more interesting part is the shape of the interface. Claudexor represents work as typed chat turns. Read-only questions can resume a vendor’s native session; write turns land as inspectable patches; races can ask different harnesses to solve the same task and then cross-review the result.

As of July 22, 2026, the repository had 164 GitHub stars, was mainly TypeScript, used the MIT license, and had been pushed the same day. The README also says it is local-first and has no telemetry. That local-first claim is important because the whole pitch depends on files, patches, auth routes, quota facts, and cost claims being things you can inspect instead of vibes you have to trust.

The trap is treating “unknown cost” as free. Claudexor’s README explicitly calls out honest budget accounting, including that unknown cost is never $0. That is a small line with a big operational consequence: if a router cannot prove what happened, it should not pretend the run was cheap.

Why developers cared on Hacker News

The author’s own motivation was ordinary in the best possible way: they were tired of switching agents when quota limits hit. They also did not want to pick one harness forever. Their post described combining several Claude Code, Codex, and Cursor subscriptions into one place, then running multi-harness loops such as “work until code review is clean.”

That pain is familiar if you use agents for real repository work. A model can be good at explaining a failure, weak at editing a migration, strong at writing tests, and unavailable five minutes later because your plan hit a limit. The tedious part is not only quota; it is losing the thread while moving between tools.

Claudexor’s bet is that the missing layer is not another chat UI. It is a small control plane that can keep session context, quota state, review decisions, protected paths, and patch output together.

There is a fair objection. Routing across multiple paid accounts can slide from “using the subscriptions I bought” into “building around limits I should respect.” Before trying any router, check the vendor terms, your workplace rules, and whether the auth model is acceptable for the repo. A clever harness is not a permission slip.

Map the idea onto Cursor skills and rules

Cursor users should look at Claudexor as a boundary problem. Cursor skills package reusable instructions and resources for the agent, while Cursor rules and files like AGENTS.md set repo behavior. A quota router decides which harness runs; your repo still has to decide what any harness is allowed to change.

That is where Cursor subagents and skills become practical instead of decorative. A “database migration reviewer” skill, for example, should not silently edit migrations, seed data, and payment code in one pass. It should know the acceptance criteria, the protected paths, and the review receipt it must leave behind.

A marketplace can help you discover capabilities. It cannot tell you whether a cursor skill is safe for your repository. When people ask how to use cursor skills well, the boring answer is still the right one: make the activation description clear, scope the files, and require an inspectable diff before merge.

Here is a concrete boundary for a payments repo:

# AGENTS.md

Agents may edit:
- app/controllers/**
- app/services/**
- test/**

Agents must not edit without explicit human approval:
- db/migrate/**
- config/credentials/**
- app/models/payment_method.rb
- app/services/payouts/**

Every agent patch must include:
- tests run
- files changed
- risk notes
- rollback note

That boundary matters even more if a project like Claudexor can race multiple harnesses. Parallel answers are useful only when the repo can reject unsafe work quickly. If you are exploring this area inside Cursor, our broader notes on the related training topic cover how rules, skills, and subagents fit together.

Try it where failure is cheap

The safest first experiment is not your main service. Pick a small repo with tests, low-risk code paths, and no production credentials. A docs site, internal CLI, or sample integration is perfect.

Start by reading the Claudexor README and checking the current install instructions from the repository. Then clone the project locally and inspect how credentials, patches, and config are represented before connecting any paid account.

git clone https://github.com/razzant/claudexor.git
cd claudexor

Do not paste production tokens into an experimental config. Do not give a router write access to secrets, deployment manifests, or payment paths on day one. If you use Cursor MCP, make the first MCP server read-only so the agent can inspect context without mutating external systems.

Claudexor is a fit when you already use more than one coding harness, hit subscription limits often, and care about comparing patches. It is probably overkill if one Cursor Agent session, a few good cursor rules, and a normal review checklist already cover your day.

For a neighboring local-agent story, see local-motion Runs Cursor Agents Locally. The shared theme is not “local is magic.” It is that developers want agent work to leave artifacts they can inspect.

Copy this skill acceptance rubric

Use this as a small Cursor rule stub before you let any routed agent or cursor agent skill touch a real repo. It is intentionally strict. Loosen it only after you have seen clean patches land.

---
description: Require safe, reviewable output from routed coding agents and Cursor skills.
globs:
  - "**/*"
alwaysApply: false
---

# Agent skill acceptance rubric

A routed agent or Cursor skill is accepted only when all checks pass.

## Scope
- The agent names the files it intends to edit before editing.
- The change stays inside the requested task boundary.
- Protected paths from AGENTS.md are not touched without explicit approval.

## Patch quality
- The output is a normal diff, not a hidden workspace mutation.
- The patch includes tests or a clear reason tests were not run.
- The agent explains any generated code that affects auth, billing, data deletion, or migrations.

## Review receipt
- The final message lists files changed.
- The final message lists commands run.
- The final message includes one rollback note.
- The final message calls out unknown cost, unknown quota state, or missing evidence instead of guessing.

## Reject immediately
- The agent edits secrets or credentials.
- The agent changes deployment config without being asked.
- The agent claims success without a diff or test evidence.
- The agent routes around an account, quota, or policy limit you have not approved.

The trap is making this rubric too abstract. “Be careful” is not a rule. “Do not edit db/migrate/** without approval” is a rule an agent, reviewer, and router can all enforce.

Common questions

• Is Claudexor a replacement for Cursor?

  No. Claudexor is better understood as a local control plane that can run Cursor CLI alongside other harnesses, not as a full replacement for Cursor’s editor workflow. The repository’s pitch is routing, quota tracking, patch inspection, and cross-harness review; Cursor still provides the IDE, Agent experience, rules, skills, and reviewable editing surface many developers use daily.

• How does this relate to the cursor skills marketplace?

  The cursor skills marketplace helps with discovering reusable agent capabilities, while Claudexor is about routing work across harnesses and subscriptions. The connection is acceptance, not shopping: any skill you install or write should have a clear activation description, scoped permissions, protected paths, and a review receipt before it is used inside a routed workflow.

• Can I use cursor skills with quota-aware routing?

  Yes, conceptually, but keep the boundary clear. Cursor skills define what an agent should know or do inside Cursor; quota-aware routing decides which harness or account handles a turn. The safe pattern is to keep skill instructions repo-scoped, store durable constraints in rules or AGENTS.md, and require inspectable patches from every routed write turn.

• When is Claudexor overkill?

  Claudexor is overkill when you are not hitting quota limits, do not compare multiple harnesses, or mostly ask read-only questions. Its value rises when you have several subscriptions, repeated agent review loops, and enough code volume to justify tracking quota, cost, auth route, and patch evidence. Small repos may only need Cursor rules and a good checklist.

Best ways to use this research

• Best for: Developers already bouncing between Cursor CLI, Claude Code, and Codex CLI who want one local place to compare patches and quota state.
• Best first artifact: A repo-level AGENTS.md boundary plus the skill acceptance rubric above. Write those before connecting more accounts.
• Best comparison angle: Compare the quality of patches, review receipts, and test evidence. Do not compare agents only by which one answers first.
• Best trap to avoid: Do not treat routing as permission. Account limits, protected files, and external MCP actions still need explicit human-approved boundaries.

Further reading

• Cursor — Skills
• Cursor — Agent
• claudexor — source

Try one honest race

Pick one low-risk bug, run two harnesses against it, and compare only the resulting diffs, tests, and review receipts. If the router cannot make the work easier to audit, it is not ready for harder code.

One methodology lens

One useful way to read this through our methodology is the Plan step: delegate first-pass decomposition and dependency mapping, review the sequencing and assumptions, and keep ownership of scope and priorities. If that split is still fuzzy, the workflow usually is too.