AI-native project management for humans and agents working together
Jility is a lightweight, beautiful, and blazingly fast alternative to JIRA, designed from the ground up for teams that use AI coding assistants. It treats humans and AI agents as equal collaborators, enabling seamless handoffs, real-time updates, and intelligent workflow automation.
- JIRA is bloated and slow - Takes forever to load, cluttered with features nobody uses
- Expensive - Per-seat pricing adds up quickly for small teams
- Not built for AI workflows - No native support for AI agents creating/managing tickets
- Poor UX - Design-conscious teams deserve better
Jility combines:
- ⚡ Speed - Built in Rust, near-instant interactions
- 🎨 Beautiful UI - Linear-inspired design that developers actually enjoy using
- 🤖 AI-native - MCP server built-in, agents are first-class team members
- 💰 Affordable - Self-hosted or per-project pricing (not per-seat)
- 🔒 Local-first - Your data stays with your code in
.jility/directory
- MCP-native - Claude Code can create, update, and manage tickets via MCP tools
- Seamless handoffs - Assign work between humans and agents with full context
- Pairing - Multiple assignees (human + agent) can work together on tickets
- Comment threads - Natural communication between team members and agents
- Activity transparency - Full audit log showing who (human or agent) did what, when
- AI-powered sprint planning - Claude Code can create sprints, estimate capacity, add tickets, and track progress autonomously
- Epic support - Organize tickets into epics with JIRA-like hierarchy and progress tracking
- Context bundling - Agents get full ticket history, comments, dependencies, and guidance
- Smart decomposition - Agents can split complex tickets into sub-tasks
- Template system - Quick ticket creation for common patterns
- Dependency tracking - Automatic detection and management
- MCP tools - 26+ tools for creating, updating, and managing tickets via Claude Code
- Precise editing - Token-efficient line-based description updates via MCP
- Full activity log - Complete history of ticket changes with timestamps and attribution
- Git integration - Link commits to tickets for traceability
- Markdown support - Comments support markdown for rich formatting
- Soft delete - Deleted tickets preserved for audit trail, don't clutter views
- Fast - Rust backend, no JVM bloat
- Lightweight - Single binary + SQLite file
- Offline-capable - Works without internet
- Mobile-friendly - Actually usable on phones
jility/
├── jility-core # Shared models, business logic
├── jility-server # Axum web server + REST API
├── jility-mcp # MCP server for AI agents
└── jility-web # Next.js frontend
Tech Stack:
- Backend: Rust (Axum, SeaORM, SQLite/Postgres)
- Frontend: Next.js 14 + Tailwind CSS + shadcn/ui
- MCP: Anthropic's Model Context Protocol
- AI Integration: Claude Code via MCP server
Jility uses Task for streamlined development:
# Install dependencies and build
task build
# Start all services (Docker)
task start
# Or run natively with hot reload
task start-dev
# Access the app
open http://localhost:3901Access Points:
- Frontend UI:
http://localhost:3901 - Backend API:
http://localhost:3900
Jility is designed to be managed via Claude Code's MCP integration:
# Create .mcp.json in project root
cat > .mcp.json <<EOF
{
"mcpServers": {
"jility": {
"command": "/path/to/jility/target/release/jility-mcp",
"env": {
"JILITY_API_URL": "http://localhost:3900/api",
"JILITY_PROJECT_ID": "your-project-id",
"JILITY_API_TOKEN": "your-api-token"
}
}
}
}
EOF
# Restart Claude Code
# Now you can use MCP tools:
# - mcp__jility__create_ticket
# - mcp__jility__create_epic
# - mcp__jility__list_tickets
# And many more!- Rust (latest stable)
- Node.js 18+ and npm
- Git
The recommended way to run Jility in development mode is using the dev.sh script. It handles both backend and frontend servers with a single command, displays color-coded interleaved logs, and manages process cleanup automatically.
# Start both backend and frontend servers
./dev.sh start
# Check status of running services
./dev.sh status
# Restart all services
./dev.sh restart
# Stop all services
./dev.sh stopWhat dev.sh start does:
- ✅ Automatically cleans up any processes on ports 3900/3901
- ✅ Starts the Rust backend on port 3900
- ✅ Starts the Next.js frontend on port 3901
- ✅ Shows color-coded logs: 🔵
[backend]and 🟢[frontend] - ✅ Handles graceful shutdown with Ctrl+C
Access points:
- Backend API:
http://localhost:3900 - Frontend UI:
http://localhost:3901← Open this in your browser
If you prefer to run services manually or need more control:
# Navigate to backend directory
cd jility-server
# Build and run in development mode
cargo run
# Or use cargo watch for auto-reload
cargo install cargo-watch
cargo watch -x runThe backend will start on http://localhost:3900.
# Navigate to frontend directory
cd jility-web
# Install dependencies (first time only)
npm install
# Create local environment file
cp .env.local.example .env.local
# Start development server
npm run devThe frontend will start on http://localhost:3901.
DATABASE_URL=sqlite://.jility/data.db?mode=rwc
JWT_SECRET=your_secret_key_here
BIND_ADDRESS=0.0.0.0:3900NEXT_PUBLIC_API_URL=http://localhost:3900/apiMigrations run automatically on backend startup. The database is stored in .jility/data.db.
To reset the database:
rm -rf .jility/data.db*
cargo run # Will recreate and run migrationsjility/
├── crates/
│ ├── jility-core/ # Shared Rust models/logic
│ ├── jility-server/ # Axum backend + REST API
│ └── jility-mcp/ # MCP server for AI agents
├── jility-web/ # Next.js frontend
├── dev.sh # Development helper script
├── Taskfile.yml # Task runner configuration
└── .mcp.json # MCP server configuration
- Quick Start - Get up and running in 5 minutes
- User Guide - Comprehensive user documentation
- Build Guide - Building Jility from source
- Quick Reference - Command reference cheat sheet
- API Reference - Complete REST API documentation
- Search API - Advanced search functionality
- Wireframes - Interactive UI mockups showing all key screens
- Project Plan - Complete development roadmap with 55 tickets across 4 phases
- CLI Collaboration Guide - Human/agent collaboration examples
- Database Schema - Database design and entity relationships
- MCP Protocol Design - Model Context Protocol implementation
- Versioning System - Ticket description versioning design
- Phase 3 Complete - Web UI implementation summary
- Phase 4 Complete - Search and sprint features
- Authentication - JWT authentication system
- Database - Database migrations and schema
- Sprint Management - Sprint planning features
- Search Implementation - Full-text search with FTS5
- Testing Guide - How to run and write tests
- MCP Server Testing - Testing the MCP server integration
// In Claude Code, use MCP tools to manage your backlog
// Create an epic for a major feature
await mcp__jility__create_epic("User Authentication System", {
description: "Complete auth with login, registration, password reset",
epic_color: "#3b82f6"
})
// Break it down into tickets
await mcp__jility__create_ticket({
title: "Build login UI",
parent_epic_id: epic_id,
story_points: 3,
labels: ["frontend", "ui"]
})
// Claude implements, you review in the UI
// Add feedback via comments
await mcp__jility__add_comment(ticket_id,
"Looks good! Let's add error handling for invalid credentials"
)- Replace expensive JIRA/Linear subscription ($10-15/user/month)
- Self-host on your infrastructure (one-time setup)
- AI agents handle routine tasks (tests, migrations, docs)
- Humans focus on creative/strategic work
- Full transparency - see exactly what agents did and why
- Plan in UI - Create epics and high-level tickets in the web interface
- Assign to Claude - Let Claude Code break down features and implement
- Review via MCP - Claude can self-review, update statuses, add comments
- Track Progress - Real-time updates in the UI as Claude works
- Iterate - Claude responds to your feedback and adjusts implementation
- ✅ CLI with ticket CRUD
- ✅ SQLite storage with migrations
- ✅ Description versioning and precise editing
- ✅ Basic local workflow
- ✅ Full MCP protocol implementation
- ✅ Agent ticket creation and management
- ✅ Context bundling for LLMs
- ✅ Template system
- ✅ Beautiful Kanban board
- ✅ Ticket detail view with markdown
- ✅ Real-time updates via WebSocket
- ✅ Command palette (⌘K)
- ✅ Agent activity dashboard
- ✅ Advanced search and filtering
- ✅ Sprint management
- ✅ Git integration
- ✅ PostgreSQL support
- ✅ Optional cloud deployment
- ✅ Foundation cleanup (MCP comments, soft delete, attribution fixes)
- ✅ Epic support with JIRA-like hierarchy
- ✅ Epic progress tracking and visualization
- ✅ Epic filtering on boards
- ✅ Color-coded epic badges
- ✅ Consolidated settings UI
- ✅ UI polish (Quick Add fixes, navigation cleanup)
Jility is feature-complete for solo developer workflows with AI assistants. Focus is now on:
- Performance optimization
- Mobile experience improvements
- Team collaboration features (future)
- Agent-first, human-friendly - AI agents are teammates, not tools
- Speed above all - Every interaction should feel instant
- Beautiful by default - Good design shouldn't be optional
- Local-first - Your data lives with your code
- Progressive disclosure - Simple by default, powerful when needed
| Feature | Jility | JIRA | Linear |
|---|---|---|---|
| Speed | ⚡ Instant | 🐌 Slow | ⚡ Fast |
| AI Agents | 🤖 Native | ❌ None | ❌ None |
| Self-hosted | ✅ Yes | 💰 Expensive | ❌ No |
| Price | 💰 Per-project | 💰💰 Per-seat | 💰💰 Per-seat |
| Local-first | ✅ Yes | ❌ Cloud-only | ❌ Cloud-only |
| Open Source | 🎯 Coming | ❌ No | ❌ No |
Jility is under active development. We'll open source once Phase 1 MVP is stable.
Interested in:
- Early access?
- Beta testing?
- Contributing to the project?
Reach out! We'd love to hear your feedback.
Jility = JiRA + Agility + Utility
A nimble, practical tool that takes the best parts of JIRA's structure while ditching the bloat, built for the age of AI-assisted development.
TBD (likely MIT or Apache 2.0)
Built with ⚡ by developers tired of slow, expensive project management tools.