CLI task management for coding agents

Your agents pick up where they left off.

Ajiya sets up a task manager in your repo, so project context carries across agent sessions. Agents use CLI commands to update phases, tickets and dependencies, then resume from the same recorded state next time. You review the work in a local dashboard with a queue, board, plan and launch status.

Get started
$npx ajiya init
agent · next session
$ ajiya next
LP-0007  api  Add course catalog endpoint
         launch · unblocks 2
$ ajiya ticket start LP-0007
■ LP-0007 in progress
$ git commit -m "Add course catalog endpoint" \
    -m "Ajiya: LP-0007"
✓ 1 ticket referenced
$ ajiya ticket done LP-0007 --test
✓ Done · 4f2a91c · tests passed
ajiya/course-catalog.md ajiya.toml
# Course catalog · phase
Goal: learners can find and enroll in a course

| ID      | App | Ticket               | Depends | Status    |
|---------|-----|----------------------|---------|-----------|
| LP-0007 | api | Course catalog API   | none    | ■ Done      |
| LP-0008 | api | Learner enrollment   | LP-0007 | ■ Started   |
| LP-0009 | web | Course player        | LP-0008 | ■ Pending  |
ajiya /a·jee·ya/ · Hausa Safekeeping. Something held in trust. Here, the task manager your agents use, kept with the code.
The problem

A new session should not mean starting from scratch.

Work needs evidence

Ajiya links completed tickets to commits. You can also require tests to pass before a ticket closes.

Work must carry across sessions

Chat context can disappear when a session ends. Ajiya keeps the plan, task status and dependencies in the repo, ready for the next session.

Launch work has dependencies

A ticket list does not show what blocks launch. Ajiya maps dependencies and highlights work that needs a person.

How it works

Record the work once. Resume it in the next session.

01
Ajiya scaffolds the task manager

The CLI sets up the manager in your repo and installs the agent instructions and commit hooks.

02
Agents plan and update through commands

Agents add phases and tickets, record dependencies, start work and close tickets with CLI commands. The manager stores that state in the repo, so another session can continue from it.

03
The web UI shows the project

The local dashboard shows the same work as an overview, ready queue, board, dependency map, plan and ticket list.

04
Git proves what is done

Each commit names one to three tickets. A ticket closes against a commit. You can also require tests to pass.

One durable plan, in two views.

A project is a repo and its apps. Phases group features. Tickets give agents a defined task, its dependencies and a done condition. The CLI and dashboard use the same repo data, so work continues across sessions.

learning-platform/
├── ajiya.toml          config · apps · launch
├── ajiya/
│   ├── accounts.md     phase
│   ├── course-catalog.md     phase
│   ├── production.md      phase · launch target
│   └── PROGRESS.md     generated
├── apps/api/           app
└── apps/web/           app
Commands

Agents use these commands to manage project work.

ajiya initSets up the manager, finds apps and plans, installs hooks and the agent kit
ajiya app addAdds an app or shared library from its folder
ajiya phase addCreates a phase and records its goal
ajiya ticket addAssigns an ID, app, dependencies and a done condition
ajiya ticket doneCloses a ticket with commit evidence; can run tests first
ajiya nextLists work that can start, with launch work first
ajiya launch setMarks a target and its dependencies as launch work
ajiya checkChecks dependency loops, evidence, files and commits
ajiya serveServes the task manager dashboard on 127.0.0.1
ajiya importImports work from TODO files, GitHub issues or an older WBS
The rules

The CLI checks the rules that keep work clear and verifiable.

A ticket needs commit evidence

A ticket closes only against a commit that names it. Add --test to require passing tests.

Each commit covers one to three tickets

A Git hook checks each commit. CI checks again if the hook did not run. Merges, reverts and chores are exempt.

Agents update work through commands

The CLI writes the task files in one format. ajiya check reports manual edits that do not match it.

Launch work follows dependencies

Set one launch target. Its dependencies also count as launch work. For example, if Go-live depends on Bookings, and Bookings depends on Accounts, all three are in scope.

Project data stays on your machine

Ajiya needs no account or model calls. Your existing agent does the planning, and the dashboard runs locally.

Use your existing tools

Ajiya works with Claude Code and Codex, and with Python, PHP, Go or JavaScript projects.

Get started

Let your agent draft the plan. Review it before work starts.

A new project
$ ajiya init
Project name? Learning Platform
Ticket prefix? LP
✓ ajiya.toml, hooks, agent kit
  1. Give your agent the project goal.
  2. It asks up to three questions, then creates phases and tickets with CLI commands.
  3. Review the launch work, assumptions and tasks that need a person.
  4. Approve the plan. Your agent can start work.
An existing project
$ ajiya init
Apps:  api (composer.json)  web (package.json)
Plans: TODO.md · GitHub issues
✓ imported as draft tickets
  1. The CLI imports your existing items without changing their wording.
  2. Your agent groups tickets into phases, merges duplicates and records completed work.
  3. It can add missing work for secrets, backups, monitoring and rollback.
  4. Review and approve the plan. Tickets from older WBS files keep their IDs as aliases.
The dashboard

Review the same plan in a local dashboard.

The dashboard has views for Overview, Next up, Board, Dependencies, Plan, Tickets, Areas and Checks. Search the plan, filter launch work and find tasks that need a person. This mock LMS project shows how Ajiya can organize a real build.

Learning Platformsample LMS project
Search ticket ID or textStatus: allLaunch-requiredEnterprise gaps
Work areasSample project plan
Course catalogAPI · course discovery
EnrollmentAPI · learner access
Course playerWeb · lessons
AssessmentsAPI · quizzes
Instructor toolsWeb · course authoring
Progress trackingAPI · learner progress
NotificationsIntegrations
Production readinessLaunch work

Ajiya tracks its own development.

A short checklist helped us build the core commands. We turned it into Ajiya tickets, then deleted it. Now we plan, commit and close every change through Ajiya. Version 0.1 is ready when its dashboard shows all launch tickets as done. If Ajiya cannot track its own build, it is not ready for your project.