Paca

AI-native. Free. Lightweight. Open-source.
The fully customizable alternative to Jira, Trello, ClickUp, and Monday.

_{✨ Sponsored by}

Getting Started · MCP Server · Paca Skills · Architecture · Contributing · Roadmap

What is Paca?

Paca is a self-hosted project management platform where AI agents and humans collaborate as equal teammates inside a Scrum team — not as chatbots bolted on the side.

Jira gives you a backlog. ClickUp gives you automations. Monday gives you dashboards. Paca gives your AI agents a seat at the table. They join sprint planning, pick up tasks from the board, write BDD specs, and adapt alongside humans in real time.

Everything about Paca — its workflow, its data model, its UI — is configurable and extendable via plugins.

Why Paca?

Core Idea: Humans and AI Agents, One Scrum Team

The central insight behind Paca is that AI agents should participate in the Scrum process, not just generate output in isolation.

In Paca, AI agents:

• Are assigned to sprints and appear on the Scrumban board alongside human teammates
• Pick up tasks from the backlog and update their status in real time
• Collaborate on BDD specs — helping Product Owners and BAs write Gherkin scenarios
• Contribute to System Design Documents — keeping the architecture visible to the whole team
• Probe, sense, and respond to emerging complexity, just like a human would

This is not automation. It is genuine collaboration — rooted in the Cynefin / Stacey framework's recognition that complex domains require teams, not pipelines.

Fully Customizable — Configuration and Plugins

Paca ships as a small, focused core. Everything else is optional.

Configuration-driven: workflows, statuses, field definitions, board layouts, sprint rules, and agent behavior are all driven by project-level configuration files. No code needed to adapt Paca to your team's process.

Plugin system: extend or replace any part of Paca via plugins. Plugins are compiled to WebAssembly (WASM) for the backend (write in Go, Rust, AssemblyScript — anything with a WASM target) and standard module bundles for the frontend. Plugins run in a sandboxed environment with a capability-based permission model; they declare exactly what host functions they need, and nothing more.

plugins/
├── backend/        # WASM modules — add custom routes, logic, data models
└── frontend/       # UI modules — add custom pages, board views, widgets

Browse and install community plugins directly from the Plugin Marketplace inside the Paca UI — no command line required. Go to Settings → Plugins → Marketplace, find a plugin, and click Install.

For local development or custom plugins, you can also install from the filesystem:

./scripts/install-local-plugin.sh ./my-plugin --api-key <your-api-key>

The P-A-C-A Cycle

Paca structures team collaboration around four phases that mirror both Scrum and the scientific method:

Plan  →  Act  →  Check  →  Adapt
  ↑                             |
  └─────────────────────────────┘

What's New in v0.12.0

• Workspace branding — customize your workspace's logo, favicon, and primary accent color from Settings → Workspace Branding. Upload a logo and favicon (PNG, JPEG, WEBP, or GIF, up to 5 MB) and pick from a curated set of accent colors, each with matching light- and dark-mode variants applied automatically across buttons, highlights, the sidebar, and the login screen.

What's New in v0.11.0

• Event-driven automation engine — a complete redesign of the automation system into a visual, n8n-style graph builder. Compose Trigger → Condition → Action flows on an interactive canvas with multi-branch switch logic, an Else fallback path, and nine built-in trigger types — including UTC cron schedules, due-date offsets, task-dependency gates, and inbound webhooks with secret-token auth. Actions can retarget linked tasks (parent, children, blockers, or explicit picks) with automatic fan-out, dispatch AI agents with custom prompts, or call external APIs. Every run is traced step-by-step in a new Run History panel, and a project-wide Dependency Map visualizes cross-task automation relationships. Plugins can contribute custom trigger, condition, and action node types via WASM.

What's New in v0.10.0

• ACP agent support — connect any Agent Client Protocol coding CLI as a Paca AI agent: Claude Code, Codex, Gemini CLI, or a custom ACP server. A lightweight local bridge (paca-acp-bridge) runs from your project's source directory and streams the conversation back to Paca over an authenticated WebSocket — no code is cloned into a cloud sandbox, and the agent uses your own local auth, git/gh credentials, and whatever MCP servers or skills you've already set up for that CLI. See apps/acp-bridge/README.md for setup.

What's New in v0.4.0

• In-app AI chat — chat with AI agents at the project level to plan work, create or update epics, stories, tasks, and documentation — all in plain English without leaving Paca

• Activity diff & revert — every field change in the activity pane now shows a before/after diff; one click reverts a change to its previous value

Key Features

• Unified Scrumban Board — humans and AI agents share a single real-time board; no separate "AI workspace"
• In-app AI chat — chat with AI agents at the project level to plan work, create or update epics, stories, tasks, and documentation in plain English
• Activity diff & revert — see a visual diff for every field change in the activity pane and revert any change with one click
• BDD Collaboration — Gherkin scenario editor co-authored by POs, BAs, and AI agents
• System Design Documents (SDD) — living architecture docs that keep AI agents contextually grounded
• MCP Server — connect Claude, custom agents, or any MCP-compatible tool directly into Paca's data layer
• Claude Code skill — /paca slash command for Claude Code; manage tasks, docs, and sprints in plain English without leaving your editor
• Real-time updates — Socket.IO delivery; everyone sees changes the moment they happen
• OpenHands-powered agents — AI agents run on the OpenHands SDK; each agent executes inside its own isolated sandbox container so your host environment is never touched
• WASM plugin sandbox — extend Paca safely; plugins cannot escape their declared permissions
• Self-hosted — runs on a single Docker Compose command; your data never leaves your infrastructure
• Lightweight by default — minimal core, no feature bloat; add only what your team actually needs

Getting Started

Option 1 — Interactive install script (recommended for production)

Runs on any Linux server with Docker. No repository clone required.

curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/install.sh | bash

The script walks you through configuration interactively and starts the full stack. Open http://your-server-ip when it finishes.

Non-interactive (CI, scripts, AI coding agents): set PACA_YES=1 — required for unattended use, since without it the script can block on a prompt with nobody there to answer it. Every other setting (database, storage, domain/HTTPS, AI agent, secrets) can be steered with an environment variable instead of accepting its default:

PACA_YES=1 bash <(curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/install.sh)

If you are an AI agent installing Paca on someone's behalf: use this script rather than hand-writing docker-compose.yml / .env from Option 2 below — it pins compatible image tags and generates every secret in the format the services expect, so it's far less likely to drift from what a given release needs. See deploy/README.md for the full environment variable reference, or the comment header at the top of scripts/install.sh for the same reference inline with the script.

Option 2 — Docker Compose (manual)

1. Create a directory and download the compose file

mkdir paca && cd paca
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/docker-compose.yml -o docker-compose.yml
mkdir -p caddy
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/Caddyfile -o caddy/Caddyfile

2. Download the environment template

curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/.env.production.example -o .env

3. Generate secure passwords and secrets

POSTGRES_PASSWORD=$(openssl rand -hex 32)
ADMIN_PASSWORD=$(openssl rand -hex 16)
JWT_SECRET=$(openssl rand -hex 32)
ENCRYPTION_KEY=$(openssl rand -hex 32)

Optional: Generate API keys if you'll use the AI agent or external integrations:

AGENT_API_KEY=$(openssl rand -hex 32)
INTERNAL_API_KEY=$(openssl rand -hex 32)

Optional: Generate MinIO credentials or use your own:

STORAGE_ACCESS_KEY_ID=$(openssl rand -hex 16)
STORAGE_SECRET_ACCESS_KEY=$(openssl rand -hex 32)

4. Update .env with your values

Edit the .env file and replace the placeholder values with the ones you generated above. Below are the required fields:

PUBLIC_URL=http://localhost
POSTGRES_PASSWORD=<use the value from step 3>
ADMIN_USERNAME=admin
ADMIN_PASSWORD=<use the value from step 3>
JWT_SECRET=<use the value from step 3>
ENCRYPTION_KEY=<use the value from step 3>
STORAGE_ACCESS_KEY_ID=<use the value from step 3 or your own>
STORAGE_SECRET_ACCESS_KEY=<use the value from step 3 or your own>

5. Start the stack

docker compose --env-file .env up -d

⚠️ Important: Save your generated passwords and secrets securely. You'll need ADMIN_USERNAME and ADMIN_PASSWORD to log in.

Login: Open http://localhost and use the admin credentials you set above.

Customizing the stack: scale down services you don't need.

```bash

External PostgreSQL (supply DATABASE_URL in .env — recommended: Neon https://neon.com)

docker compose --env-file .env up -d --scale postgres=0

AWS S3 instead of MinIO (set STORAGE_PROVIDER=s3 in .env)

docker compose --env-file .env up -d --scale minio=0

Without Agent Runner (reduces resource usage)

docker compose --env-file .env up -d --scale agent-runner=0 ```

Upgrading to a new version

From the directory where your docker-compose.yml and .env live, run the upgrade script published with each release — it refreshes docker-compose.yml and the Caddyfile (with backups) and restarts the stack:

curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/upgrade.sh -o upgrade.sh
bash upgrade.sh

Database migrations run automatically on API startup. Non-interactive (CI, AI agents): set PACA_YES=1, same as install.sh — see deploy/README.md for the full env var reference, pinning a specific version, or passing through --scale flags.

Option 3 — Local development

# Clone the repository
git clone https://github.com/Paca-AI/paca.git && cd paca

# Start infrastructure dependencies (PostgreSQL + Valkey)
docker compose -f deploy/docker-compose.dev.yml up -d postgres valkey

# Or start the full dev stack in containers
docker compose -f deploy/docker-compose.dev.yml up -d

See docs/guides/local-development.md for running services on the host for active development.

MCP Server — Connect Any AI Agent to Paca

Paca ships an MCP (Model Context Protocol) server that gives any compatible AI agent direct, structured access to your workspace — projects, tasks, sprints, documents, members, and more. No scraping, no custom APIs to wire up.

The server is published as @paca-ai/paca-mcp on npm. You run it with npx; your MCP client handles the rest.

Claude Desktop

1. Open (or create) the Claude Desktop config file: - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json - Windows: %APPDATA%\Claude\claude_desktop_config.json

2. Add the paca entry:

{
  "mcpServers": {
    "paca": {
      "command": "npx",
      "args": ["-y", "@paca-ai/paca-mcp"],
      "env": {
        "PACA_API_KEY": "your-api-key-here",
        "PACA_API_URL": "http://localhost:8080"
      }
    }
  }
}

1. Restart Claude Desktop. Claude now has access to all Paca tools and can answer requests like: - "List all active sprints in project X" - "Create a task for implementing OAuth and assign it to sprint 3" - "Add a comment to task #42 with my progress update"

Other MCP-Compatible Clients

Any client that speaks MCP works. Typical configuration:

{
  "name": "paca",
  "command": "npx",
  "args": ["-y", "@paca-ai/paca-mcp"],
  "env": {
    "PACA_API_KEY": "your-api-key-here",
    "PACA_API_URL": "http://your-paca-instance:8080"
  }
}

Environment Variables

Available Tools

The server exposes tools across these categories:

For a complete reference and advanced configuration (agent-mode, plugin tools, programmatic usage), see docs/guides/mcp-server-setup.md.

/paca skills — Claude Code, Gemini CLI, Cursor, and more

Install the Paca skill set and manage your entire Paca workspace through natural-language slash commands — without leaving your editor and without creating local files. Every command reads your Paca documentation first to understand the project before acting.

Skills use the Agent Skills format (YAML frontmatter + instructions) and are served by a running Paca instance's own API (GET /api/v1/skills), not read from a checked-out directory — so installed content always matches the exact version that instance runs. The install script fetches and installs them to Claude Code (~/.claude/commands/), Gemini CLI (~/.gemini/commands/), Cursor (.cursor/commands/, project-scoped), and any AGENTS.md-reading tool (project-scoped) in one pass, and also pulls in skills contributed by your installed plugins. See docs/guides/install-skills.md for details.

Install

Point the installer at a running Paca instance and run this once in your terminal to install all skills to every supported platform found on this machine:

PACA_API_URL=http://localhost:8080 \
  curl -fsSL https://raw.githubusercontent.com/Paca-AI/paca/master/scripts/install-paca-skills.sh | bash

Then connect the Paca MCP server to Claude Code:

claude mcp add paca \
  --env PACA_API_KEY=<your-api-key> \
  --env PACA_API_URL=<your-paca-url> \
  -- npx -y @paca-ai/paca-mcp

Run /paca-setup inside a Claude Code session for a guided interactive walkthrough instead.

Available commands

For full setup options and command reference, see docs/guides/install-skills.md.

Architecture

apps/web              React + TanStack Start + shadcn/ui — user interface
apps/mcp              @paca-ai/paca-mcp — MCP server for AI agent integration
services/api          Go + Gin — core business logic and REST API
services/realtime     Node.js + Socket.IO — real-time event fan-out
services/agent-runner Go — AI agent execution (Goose over ACP)
services/agent-server Docker image for the Goose sandbox agent-runner spawns per conversation
apps/e2e              Playwright — end-to-end test suite

PostgreSQL        Persistent store
Valkey            Cache + async event streams between services

See docs/architecture/overview.md for detail.

The "Paca" Story

The name is a small pun on the Japanese word "Baka" (ばか) — "silly."

In the early days, we jokingly called our AI assistants "silly" when they hallucinated. And building a serious project management platform as a free, open-source alternative to multi-billion-dollar tools might also seem a bit silly.

But Paca is built from conviction: human-AI collaboration in a real Scrum team should be accessible to every team, everywhere — not locked behind a vendor's pricing model. We think that's worth being a little foolish about. 🦙✨

Documentation

License

Distributed under the Apache License 2.0. See LICENSE for details.