Keyboard-first boards and sprints
Drive the whole board from one Cmd+K palette — search, navigate, and run actions without leaving the keys. Drag across columns, plan sprints, and read burndown in the same view.
Open source · MIT · AI-native
The project tracker built for teams and their agents.
TaskNebula is the open-source, keyboard-first alternative to Jira and Linear. Boards, sprints, and docs that run on your own Postgres — with a built-in MCP server so AI agents work the backlog right beside your team. MIT licensed, self-host with one Docker Compose.
Or self-host in two commands
$ curl -fsSLo compose.yml https://raw.githubusercontent.com/neuraparse/tasknebula/main/docker-compose.desktop.yml
$ docker compose up -dFree forever self-hosted · Three containers: Postgres, Redis, one web image
Interactive demo belowCmd+K everywhereMCP server built inJira & Linear importSelf-host on your Postgres
Board
A board you can actually move through.
Switch projects, drag issues between stages, and keep details close without fake motion or noisy chrome.
TaskNebula Board
Workspace preview
LiveWebsite / Current sprint
WEB-18high
Refine launch page hierarchy
Tighten hero, simplify copy, and make the landing feel more premium.
Stage In ProgressOwner SK4 comments3/5
Checklist
Reduce copy density
Improve visual rhythm
Finalize CTA placement
Open source, self-hosted, your data stays yours. No logo wall — just receipts you can check.
The workflow
From keystroke to ship — one open backlog.
Plan, execute, and reason over the work in the same surface. Keyboard-first delivery, an AI layer you can audit, and agents that move tickets through a real MCP server — all MIT-licensed and self-hostable.
Import from Jira and Linear
Bring your backlog with you — Jira, Linear, and CSV importers map issues, statuses, and metadata so you start full, not empty.
0.4.0
Jira-parity structure
First-class labels, components, fix versions, and a resolution model — backlog structure stored in real tables and REST APIs, not JSON strings.
AI-native, auditable
Real OpenAI and Anthropic calls behind a cost guard and tracing — triage suggestions, AI estimates, and a /api/ask RAG endpoint over pgvector. No black boxes.
Agents work the backlog
A real MCP server — HTTP at /api/mcp or stdio — lets coding agents create, search, and move issues. Backed by a REST API, OpenAPI spec, revocable keys, and webhooks.
Realtime collaboration
Specs and issue docs edit live — Tiptap on Yjs with presence and conflict-free merges, so two people on one doc just works.
Self-host in minutes
One Docker image, Postgres, and you own the data. Multi-tenant from the schema up — every table is organization-scoped, no vendor lock-in.
Analytics close to execution
Velocity, cycle time, and priority mix per project — with a resolution model that separates Done from Won't Fix and Duplicate.
The flow
One thread from intake to shipped.
No tool-hopping between a tracker, a planning doc, and an agent console. The work moves through a single surface — humans and agents on the same timeline.
- STEP 01
Intake without the noise
Issues, requests, and inbound from your agents land in one queue. Triage suggests priority and labels so the backlog starts structured, not as a pile.
- STEP 02
Plan the sprint in place
Pull from the backlog into a sprint, set fix versions and components, and read scope at a glance. Planning lives next to the work, not in a separate doc.
- STEP 03
Build alongside agents
Agents are first-class teammates over MCP — they pick up issues, comment, and open work the same way people do, with every action on the shared timeline.
- STEP 04
Ship and track the outcome
Close issues with a real resolution, cut the version, and watch velocity and cycle time update live. Done means done — not a column you forgot to clear.
AI-native
Agents work the backlog with you.
TaskNebula was built for the agent era. Ask questions across your whole workspace, let AI triage and estimate new work, and give external agents real tools through a first-class MCP server.
Ask your workspace
The /api/ask RAG endpoint answers in natural language over your issues, docs, and comments — grounded in pgvector retrieval, with citations back to the source.
AI triage & estimates
Suggested priority, labels, and effort land on new issues — backed by real OpenAI and Anthropic calls, a cost guard, and tracing. You stay in control: accept or dismiss.
MCP tools for agents
@tasknebula/mcp-server exposes the backlog over MCP — HTTP at /api/mcp or stdio — so external agents create, search, and move issues with revocable keys.
Compare
TaskNebula vs Jira vs Linear vs Plane
All four are capable tools. Here is exactly where TaskNebula differs — open by default, yours to host, AI-native. Nothing more, nothing less.
| Feature | TaskNebula | Jira | Linear | Plane |
|---|---|---|---|---|
| Open source (MIT) | Yes: Entire codebase, MIT | No: Proprietary | No: Proprietary | Partial: AGPL-3.0 core |
| Self-host (one Docker Compose) | Yes: Postgres + Redis + one web image | No: Cloud-first; DC phased out | No: Cloud only | Yes: Docker / Kubernetes |
| Price | Yes: Free, unlimited users, self-hosted | Partial: Free ≤10 users, then per-seat | Partial: Free tier, then per-seat | Partial: Free ≤12 users, then per-seat |
| AI agents native + MCP server | Yes: Built-in agents + MIT MCP server | Partial: Rovo + remote MCP, cloud-only | Partial: AI + remote MCP server | Partial: Plane AI (credits) + MCP |
| Keyboard-first | Yes: Command palette + shortcuts | Partial: Limited shortcuts | Yes: Best-in-class | Yes: Command-K palette |
| Realtime collab | Yes: Live cursors via Yjs | Partial: Live sync, no co-editing | Yes: Live sync | Yes: Live sync |
| Jira / Linear import | Yes: CSV + API import | Partial: Imports to Jira | Yes: Jira import built-in | Yes: Jira / Linear importers |
| Sprints / Cycles | Yes: Sprints + backlog | Yes: Scrum + Kanban | Yes: Cycles | Yes: Cycles + modules |
| Labels / Components / Versions | Yes: First-class, all three | Yes: All three | Partial: Labels + projects | Partial: Labels + modules |
| API / Projects-as-code | Yes: Open REST + OpenAPI spec | Partial: REST API, no IaC | Partial: GraphQL API | Partial: REST API |
YesPartialNo
Vendor details reflect public documentation and pricing pages as of June 2026 and may change. Jira is a trademark of Atlassian, Linear of Linear Orbit, and Plane of Plane Software — all are solid products, none affiliated with TaskNebula.
Migrate
Move from Jira or Linear in an afternoon
Switching tools shouldn't mean losing your history or your process. Import what you have, map it to TaskNebula, and keep working the way your team already does.
Bring your issues over
Import issues from Jira and Linear with their descriptions, comments, and history intact — not flattened into a CSV dump.
Labels and sprints come too
Labels, components, and active sprints land as first-class records, so your boards and backlog look familiar on day one.
Map fields, not just names
Match statuses, priorities, and custom fields to TaskNebula equivalents during import — review the mapping before anything writes.
Keep your workflow
Your statuses, swimlanes, and conventions move with you. Switch tools without retraining the team or rebuilding process from scratch.
Imports run against your own database and are fully reversible — nothing leaves your server, and you can re-run a mapping until it looks right.
Self-host
Your work. Your server. Your data.
Three containers and one command. Everything lives in your Postgres, exporting is a pg_dump away, and nothing phones home — no vendor lock-in by design.
One Postgres, one web image
Postgres 16 with the pgvector extension powers search; Redis 7 is along for the ride. No Mongo, no Elastic, no sidecar zoo.
Migrations run on boot
The image applies every database migration at startup. Upgrading is pulling a newer tag and restarting — nothing manual.
Health you can probe
GET /api/health returns 200 when the app is ready — wire it to your load balancer, uptime checks, or compose healthcheck.
Pin the version you trust
Set TASKNEBULA_IMAGE=neuraparse/tasknebula:0.4.0 to lock a release, or follow :latest for the bleeding edge.
quickstart — Docker Desktop or any Docker host (~2 min)
$ mkdir tasknebula && cd tasknebula$ curl -fsSLo compose.yml https://raw.githubusercontent.com/neuraparse/tasknebula/main/docker-compose.desktop.yml$ docker compose up -dThe web image waits for Postgres, runs migrations, then serves on http://localhost:3000 — open it and finish the first-run admin wizard. Image: neuraparse/tasknebula.
FAQ
Fair questions, straight answers.
No sales gate, no asterisks. If yours is missing, open a GitHub issue — public answers beat private threads.
Is TaskNebula really free, and really MIT?
Yes — the whole app is MIT licensed: boards, sprints, docs, analytics, the AI surfaces, and the MCP server. No open-core split, no paywalled tier, no per-seat fee. Self-host it and run it forever for unlimited users; fork it if you want to.
Can I self-host it?
That is the default. Bring Docker and you get three containers — Postgres 16 with pgvector, Redis 7, and the neuraparse/tasknebula web image. Migrations run on boot, GET /api/health is your probe endpoint, and a one-line compose quickstart gets you to localhost:3000. There is no hosted-only feature you lose by running it yourself.
Do I need the AI features? Can I bring my own keys?
AI is optional — every board, sprint, and doc works with no model keys configured. When you want it, you bring your own OpenAI or Anthropic key (set as env vars), so spend and data residency stay yours. There is a cost guard so a runaway prompt cannot run up your bill.
How real are the AI features today?
We build them in the open. The data model and endpoints — triage suggestions, pgvector semantic search, and the /api/ask RAG endpoint — are live, and they make real OpenAI and Anthropic calls. Some surfaces are still labeled preview while we harden them; we would rather say that here than have you discover it after install.
What is the MCP server?
An MCP (Model Context Protocol) server that exposes TaskNebula as tools — create, search, move, and comment on issues — so agents like Claude Code and Cursor can drive your tracker. It ships with the repo (HTTP at /api/mcp, or stdio via @tasknebula/mcp-server) and is MIT licensed. Heads up: end-to-end agent auth depends on the REST API accepting API keys, which is still being wired, so treat it as preview today.
Does it import from Jira or Linear?
Yes — there are importers for Jira, Linear, GitHub, and CSV. Each runs with a preview step so you can inspect the field mapping before anything is written, and you can keep your old tool read-only while you cut over.
Is it production-ready?
The core tracker — issues, boards, sprints, docs, search, permissions, REST API, and OpenAPI spec — is solid and self-hostable. Some edges are still maturing: OAuth login needs a DB adapter (use credentials auth for now), realtime collab env vars are not yet plumbed into the Docker images, and parts of the AI/MCP surface are preview. We track all of it openly in docs/STATUS.md.
Who can see my data?
You decide. Self-hosted, everything lives in your Postgres on your infrastructure and exports with a plain pg_dump — no telemetry phones home. Inside the product, workspaces are isolated per organization with role-based access, permission schemes, and audit logs.
Still unsure? Ask on GitHub or read the live status in the docs.
Get started
Own your tracker. Bring your agents.
Create a workspace in minutes, or run the whole thing on your own box tonight — either way, the code is yours to read.
$ docker compose up -dNo credit card. No telemetry by default. Export with a pg_dump whenever you leave.