The issue tracker your AI agents run on.
Fast, git-native task tracking built for AI agents — that also orchestrates them. Plan a roadmap, run agents in parallel, ship wave by wave.
Right model for each job — frontier where it pays off, cheaper tiers for the rest. Stop paying premium rates to run one model on everything.
Many agents in parallel, each in its own auto-managed git worktree — no babysitting.
Your issues are JSON in your repo. No daemon, no database, no backend required.
See the swarm
ticks reads the dependency graph, decomposes it into waves, and runs each ready
tick as its own agent in an isolated git worktree. Waves merge back wave by wave,
unblocking the next. This is real tk graph output — five ticks, three waves.
blocked_by (hard dependency)
after (soft ordering)
merged → next wave unblocks
Features
Because unstructured notes can't be orchestrated — structured ticks can. You can't compute parallel waves, a dependency graph, a critical path, or "what's ready and unblocked for me right now" from prose in a TODO.md or an agent's throwaway todo list — and two agents editing one markdown file collide. Structured ticks (status, priority, blocked_by/after edges, owners, acceptance, notes — each a JSON file) are exactly what make tk graph, waves, and cross-runner handoff possible.
Issues survive context compaction, session restarts, and switching between AI tools. Agents never lose the thread.
One JSON file per issue, versioned with your code; a native merge driver resolves concurrent edits. No daemon, no database, no proprietary or cloud backend required. Your issues live in your repo and travel with it.
tk ready returns in ~35ms over 1000 issues; tk next and --json are designed for agents to parse.
A team of humans and their agents share one repo without stepping on each other. Owner scoping keeps each agent on its own ticks, so concurrent work stays conflict-free.
tk graph computes dependency waves; the orchestrator runs one agent per ready tick in its own auto-created git worktree, keeps them from clobbering each other, and integrates wave by wave. Daemon-free, no worktree babysitting.
Frontier-tier planning where it pays off, cheaper tiers for the wide parallel implementation work. Frontier-quality decomposition without paying premium rates on every edit — the direct answer to token fatigue.
Chain epics with hard (blocked_by) and soft (after) edges; runner-neutral across Claude Code and Codex, with branches/worktrees/notes as the durable handoff format so any runner can resume any epic. Humans stay in the loop via approval/review/checkpoint gates.
Every epic ends with a structured retro that promotes what was learned — what worked, what broke — into .tick/learnings.md and repo docs. Every future planning pass and implementer reads that memory, so the same mistakes don't repeat and orchestration improves over time.
How It Works
Single binary, no dependencies. Works on Mac, Linux, and Windows: curl -fsSL https://ticks.sh/install | sh. Then add the orchestration skill to Claude Code or Codex with npx skills add pengelbrecht/ticks.
Run tk init once, then just describe the goal. Your agent breaks it into an epic of dependency-linked ticks — hard (blocked_by) and soft (after) edges — so the work orders itself.
Tell your agent to run the epic. Through the ticks skill (Claude Code or Codex) it reads the dependency graph and runs one agent per wave in isolated worktrees, integrating wave by wave. Open tk board to watch.
you ▸Build authentication — plan it into an epic and run it.
agentBreaking it down into ticks…
$ tk create "Authentication" --type epic
$ tk create "DB schema" --parent auth
$ tk create "User model" --parent auth --blocked-by schema
5 ticks · 3 waves · max 2 parallel
$ tk graph auth
agentLaunching wave 1 — two agents in isolated worktrees…
▸ schema ▸ oauth running in parallel
✓ wave 1 merged → wave 2 unblocked
✓ epic complete — 5 ticks, all green
You speak plain language; your agent drives the tk CLI. Same primitives work interactively, headless, or in CI — across Claude Code and Codex.
Free and open source. Set up in under a minute.