Introduction
"The best tools are invisible — they amplify your natural workflow instead of forcing you to adapt to them."
This is the 172nd article in the "One Open Source Project a Day" series. Today's project is Kaneo.
Have you used Jira? Anyone who has probably remembers this: before you can create a single ticket, you need to configure a project type, a workflow scheme, a permission scheme, a notification scheme — getting started alone can eat an entire afternoon.
Kaneo is a direct reaction to that experience. Its design principle fits in one line: "All you need. Nothing you don't."
Kanban board, list view, GitHub integration, a built-in MCP server, one-command Docker deployment — features that actually matter, with no buttons that don't. 8.9k Stars, MIT license, fully self-hosted, your data stays yours.
What You Will Learn
- Kaneo's Hono + React + PostgreSQL tech stack
- How the built-in MCP server lets Claude, Cursor, and other AI tools manage project tasks directly
- How GitHub and Gitea integrations work
- The data model behind the Board and List dual-view design
- Four deployment paths: drim CLI, Docker Compose, Coolify, and Kubernetes Helm
Prerequisites
- Familiarity with the Kanban workflow concept
- Basic Docker usage
- Optional: basic awareness of MCP (Model Context Protocol)
Project Background
What It Is
Kaneo (pronounced /kəˈneɪ.oʊ/) is a self-hosted, minimal project management tool.
Its positioning is clear: not a feature-for-feature Jira replacement, but a philosophical rebellion against what Jira represents.
Jira represents the "pack every conceivable requirement into the tool" design philosophy. Kaneo represents "only include what teams actually need." From the official description: ""
"Kaneo was built as a reaction to bloated, overcomplicated project management platforms. Every unnecessary button, every complex workflow, every feature that exists to impress in demos rather than solve real problems — all of it pulls your team's attention away from building."
In terms of features, Kaneo offers: kanban boards, list views, backlog management, task assignment and priorities, labels, comments, time tracking, workflow automation, team member management, and a public API.
What it deliberately omits: complex permission schemes, custom issue-type hierarchies, and third-party marketplace apps.
Author / Team
- Lead maintainer: andrejsshell (Kaneo team)
- Origin: Founder Andrej describes the ideal tool as "invisible" — one that amplifies natural team workflows rather than imposing new ones
- Website: kaneo.app
- Cloud: cloud.kaneo.app
- Community: Discord
Project Stats
- ⭐ GitHub Stars: 8,900+
- 🍴 Forks: 746
- 📄 License: MIT
- 💻 Primary Language: TypeScript (React + Hono)
- 🌐 Website: kaneo.app
- 📦 Image:
ghcr.io/usekaneo/kaneo:latest
Core Features
What Problem It Solves
Kaneo provides a complete project management workflow from planning to execution:
Workspace
↓
Project
↓
┌──────────────────┬──────────────────┐
│ Board view │ List view │
│ Kanban drag-drop │ Filter & sort │
└──────────────────┴──────────────────┘
↓ Shared single data source
(statuses, priorities, labels stay in sync)
Task
├── Owner + due date
├── Priority (P0–P3)
├── Labels (custom)
├── Comments + time tracking
└── Task relations (dependencies, etc.)
Usage Scenarios
-
Small team replacement for Jira
- No need for Jira's permission schemes and custom workflows — just kanban and task management. Kaneo goes from zero to usable in minutes, not days.
-
AI-assisted task management
- With the built-in MCP server, create, query, and update tasks from a Claude or Cursor conversation — no need to open a browser.
-
Self-hosted data sovereignty
- Docker deployment, data stored in your own PostgreSQL instance, no third-party services required.
-
Development team GitHub sync
- See GitHub Issue status directly in Kaneo; manage product planning and code development from a single view.
-
Notification integrations
- Supports Discord, Slack, Telegram, email, ntfy, Gotify, and webhooks — connect whichever notification channel your team uses.
Quick Start
Simplest path (drim CLI):
curl -fsSL https://assets.kaneo.app/install.sh | sh
drim setup
Handles HTTPS, database configuration, and service startup automatically. Best for server deployments.
Docker Compose (local or small production):
# docker-compose.yml
services:
postgres:
image: postgres:16
environment:
POSTGRES_DB: kaneo
POSTGRES_USER: kaneo
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
ports:
- "5432:5432"
kaneo:
image: ghcr.io/usekaneo/kaneo:latest
environment:
DATABASE_URL: postgresql://kaneo:${POSTGRES_PASSWORD}@postgres:5432/kaneo
AUTH_SECRET: ${AUTH_SECRET}
KANEO_CLIENT_URL: http://localhost:5173
ports:
- "5173:5173"
depends_on:
- postgres
# Generate AUTH_SECRET
openssl rand -hex 32
# Start
docker compose up -d
# Open http://localhost:5173
Local development:
git clone https://github.com/usekaneo/kaneo.git
cd kaneo
pnpm install
pnpm dev
Core Features
1. Board + List dual views
Both views share the same data; statuses, priorities, and labels stay synchronized in real time:
- Board view: Kanban drag-and-drop, visual task flow, ideal for daily standups
- List view: Table format with multi-dimensional filtering and sorting, ideal for sprint planning and bulk operations
Switching views loses nothing and requires no reconfiguration — something many tools get wrong.
2. Built-in MCP server
Kaneo ships a built-in HTTP MCP endpoint at /api/mcp, allowing AI tools to operate project tasks directly:
// Claude Desktop config — claude_desktop_config.json
{
"mcpServers": {
"kaneo": {
"command": "npx",
"args": ["-y", "@kaneo/mcp"],
"env": {
"KANEO_URL": "http://localhost:5173",
"KANEO_API_KEY": "your-api-key"
}
}
}
}
Once configured, you can say in a Claude conversation:
- "Create a task in [project name]: Implement user registration, priority P1"
- "Show all high-priority unfinished tasks this week"
- "Reassign task #42 to Alice"
3. GitHub and Gitea integration
Authorizing via GitHub App lets Kaneo sync GitHub Issues:
- GitHub Issues are visible and status-synced in Kaneo
- Development branches link to tasks; PR merges automatically update task status
- Gitea (self-hosted Git service) is also supported
4. Backlog management
A dedicated backlog area holds tasks that are planned but not yet in active execution. Drag them into the board on demand — keeps future work from cluttering the current sprint's view.
5. Workflow automation
Custom columns and automation rules, for example:
- When a task moves to "In Review," automatically notify the assignee
- When a deadline approaches, automatically increase priority
- When a PR merges, automatically move the linked task to "Done"
6. Authentication and SSO
Multiple authentication options are available — all free on self-hosted:
- Username + password
- GitHub OAuth
- Google OAuth
- Discord OAuth
- Custom OIDC (enterprise SSO)
This is a key difference from Jira, where SSO requires a Guard or Enterprise tier subscription. Kaneo makes it available at no cost on self-hosted.
Comparison with Jira
| Dimension | Jira | Kaneo |
|---|---|---|
| Time to first use | Workflow + permission + notification scheme setup | Minutes |
| SSO | Requires Guard/Enterprise subscription | Free on self-hosted |
| Self-hosting license | Requires Data Center annual fee | MIT, free |
| Cloud pricing | Per-user, higher cost | From $4/month |
| MCP / AI integration | None | ✅ Built-in |
| Data ownership | Hosted by Atlassian | Fully self-controlled |
| Best for | Large enterprises with complex workflows | Small teams, fast iteration |
Deep Dive
Tech Stack: Hono + React + PostgreSQL
apps/
web/ ← React + TypeScript + Tailwind (frontend)
api/ ← Hono + TypeScript (backend)
packages/
mcp/ ← @kaneo/mcp npm package (MCP stdio client)
db/ ← PostgreSQL schema + migrations
Deployment artifacts:
ghcr.io/usekaneo/kaneo ← Single bundled image (recommended)
ghcr.io/usekaneo/web ← Frontend standalone image
ghcr.io/usekaneo/api ← Backend standalone image
The choice of Hono as the backend framework is notable:
- Much lighter than Express (~12 KB)
- TypeScript-native with no extra configuration
- Cross-runtime (Node.js, Deno, Bun, Cloudflare Workers)
- Built-in middleware for auth, CORS, logging, and other common needs
Two MCP Integration Modes
Kaneo's MCP support comes in two usage modes:
HTTP endpoint (server-embedded):
POST /api/mcp
Suitable for web clients and tools that support HTTP MCP.
stdio package (npm):
npx -y @kaneo/mcp
Suitable for Claude Desktop, Cursor, and other stdio-based MCP clients.
Both modes expose the same tool set, covering full CRUD operations for projects, tasks, and labels.
Deployment Options
| Method | Best for | Complexity |
|---|---|---|
| drim CLI | One-click server production deploy | ★☆☆ |
| Docker Compose | Local dev or small production | ★★☆ |
| Coolify | Self-hosted PaaS users | ★★☆ |
| Helm / Kubernetes | Enterprise cluster deployment | ★★★ |
The bundled single image (ghcr.io/usekaneo/kaneo:latest) is the simplest path — frontend and backend packaged together. Separate images (api + web) suit production environments that need independent scaling.
Storage and Notification Extensions
Object storage (attachments):
S3-compatible interface; plugs into MinIO (self-hosted), AWS S3, or Cloudflare R2.
Notification channels:
- Discord, Slack, Telegram
- ntfy, Gotify (self-hosted notification services)
- Webhook (generic outbound)
The breadth of notification coverage — especially ntfy and Gotify support — shows genuine understanding of the self-hosted user ecosystem. These aren't throwaway additions; they're the notification services that self-hosters actually run.
Why "Minimal" Is Hard
Most tools that call themselves "minimal" are just incomplete. Kaneo's version of minimal is different: it has all the features a real team needs — backlog, dual views, SSO, GitHub sync, workflow automation, time tracking, notifications — but none of the configuration overhead that makes those features feel like work to set up.
The distinction shows up in how Kaneo handles SSO: rather than putting it behind a paid tier as a "premium" feature, it ships unlocked from day one on self-hosted. The tool trusts you to use it.
Project Links & Resources
Official Resources
- 🌟 GitHub: https://github.com/usekaneo/kaneo
- 📚 Docs: kaneo.app/docs/core
- 🌐 Website: kaneo.app
- ☁️ Cloud: cloud.kaneo.app
- 💬 Discord: discord.gg/rU4tSyhXXU
- 📦 Docker image:
ghcr.io/usekaneo/kaneo:latest
Related Projects
- Hono — the ultra-lightweight web framework powering Kaneo's backend
- Planka — another open-source Trello alternative; Kaneo provides a migration tool from Planka
- Linear — commercial product with a similar speed-first philosophy; Kaneo has a dedicated comparison page
Summary
Key Takeaways
- 'Less is more' is a design principle, not an excuse: every feature solves a real problem — no demo-ware
- Built-in MCP server is the standout differentiator: a project management tool with a native AI interface, manage tasks straight from Claude or Cursor
- Hono backend: lightweight, TypeScript-native, cross-runtime — deliberate technology choices with clear reasoning
- SSO is free: all authentication options available on self-hosted with no paywall
- Notification ecosystem depth: ntfy and Gotify support shows genuine consideration for the self-hosted user community
Who This Is For
- Small teams exhausted by Jira's configuration overhead: up and running in minutes, not days
- Development teams that value data sovereignty: MIT license, self-hosted, no data touches third-party infrastructure
- AI tool power users: manage tasks through MCP from Claude or Cursor, reducing context switching
- Open-source and self-hosting enthusiasts: full Docker + Helm + Coolify support, deploy wherever you want
One-Line Verdict
Kaneo's answer isn't "fewer features" — it's "exactly the right features." Those two things sound the same. They're not.
Check out PrimeSkills — a curated marketplace of AI agents and skills that have been validated in real-world, enterprise-grade workflows. No fluff, just what actually works.
Find more useful knowledge and interesting products on my Homepage
Top comments (0)