Traycer
Planning and tracking layer for coding agents
About Traycer
Traycer solves a problem that only exists because coding agents got good. Once you are running Claude Code, Codex or Cursor on real work, the constraint stops being whether the agent can write the code and becomes whether it stays on track: agents wander, lose the thread across a long task, duplicate work, and give you no shared view of what has actually been done. Traycer is a workspace that sits above the agents and handles the planning and tracking they are bad at.
The key design decision is that it does not replace your agent. It connects to whichever one you already use, and the free tier is explicitly built around that: bring your own agent, and Traycer handles planning, task tracking and keeping it on rails, with no credit meters and no inference costs of its own. That is an unusually honest structure. You are already paying a model provider, and a coordination layer that charges again per token would be selling you the same tokens twice.
The second thing it adds is a shared surface. Individual agent sessions are private conversations; a team running several agents has no common view of what is in progress. Traycer makes plans and task state visible, which turns agent work into something a team can coordinate around rather than something each developer does invisibly.
You connect an agent. Claude Code, Codex, Cursor, OpenCode and others are supported, and the connection is the point: your existing setup and subscription keep working.
You describe the work, and Traycer produces a plan broken into tracked tasks rather than handing the whole thing to an agent as one prompt. This is the step that prevents an agent from drifting halfway through a large job.
Agents then execute against those tasks, with Traycer holding the state of what is planned, in progress and finished. Because the plan is external to any single agent session, work survives a session ending and can be picked up again.
Agent-to-agent communication means more than one agent can work within the same plan, which is where the coordination value shows up: two agents on one codebase without a shared plan produce conflicts, not throughput.
- •Bring your own agent - works with Claude Code, Codex, Cursor, OpenCode and others rather than replacing them, so your existing subscription and habits carry over.
- •No token metering on the free tier - Traycer charges for coordination, not inference, so you are not paying twice for the same model calls.
- •AI planning - work is decomposed into tracked tasks before execution, which is the specific failure mode agents have on long jobs.
- •Task tracking that outlives a session - plan state lives outside any single agent conversation, so nothing is lost when a session ends.
- •Unlimited agent sessions - even on the free tier, so the limit is your model provider's, not Traycer's.
- •Agent-to-agent communication - several agents can work within one plan without colliding.
Developers already running coding agents daily are the audience, and the value only makes sense once you have hit the problem. If you use an agent occasionally for small edits, there is nothing here for you. If you have watched an agent lose the plot two hours into a refactor, the pitch lands immediately.
Teams sharing a codebase get the coordination benefit. Agent work is invisible by default, and a shared plan turns it into something reviewable and assignable.
Anyone cost-conscious about agentic coding should note the structure. A free tier with unlimited sessions and no inference charge is a genuinely different commercial model from tools that resell you model access with a margin.
It is not a coding agent and will not write code for you. If you are looking for the thing that does the work rather than the thing that organises it, this is the wrong layer of the stack.
Pricing
$0 - $100/mo
- Free$0/mo
- Team$10/mo
- Starter$20/mo
- Pro$40/mo
- Max$100/mo
From the vendor pricing page, 2026-09-22
