Paca

Introduction

Paca is a free, open-source, self-hosted project management platform that reimagines Scrum boards for the age of AI agents. Where Jira gives you a backlog and ClickUp gives you automations, Paca gives your AI agents a seat at the table — they join sprint planning, pick up tasks from the board, write BDD specs alongside Product Owners, and contribute to system design documents, all on the same real-time Scrumban board as human teammates.

Launched in April 2026 and built with Go (45.7%), TypeScript (42.9%), Gherkin (6.5%), and Python (2.5%), Paca hit 878 GitHub stars by mid-June 2026 after a Show HN post that gathered 165 points. Version 0.4.3 was released on June 14, 2026. It is distributed under an Apache 2.0 license — fully open-source, free forever, no per-seat pricing.

AI agents should participate in the Scrum process, not just generate output in isolation. They are assigned to sprints, appear on the board next to humans, and collaborate on artifacts like BDD scenarios and architecture docs.

Key Features

AI Agents as First-Class Scrum Members

This is Paca's core feature. AI agents are not chatbots bolted onto the side of a project management tool — they are genuine teammates on the board:

• Assigned to sprints — agents appear in the sprint backlog like any human
• Visible on the Scrumban board — agents' tasks move through To Do → In Progress → Done alongside human tasks
• Pick up tasks — agents can claim work from the backlog and update status in real time
• Collaborate on BDD specs — Product Owners, BAs, and AI agents co-write Gherkin scenarios
• Contribute to System Design Documents — living architecture docs keep every agent contextually anchored

Paca structures collaboration around the P-A-C-A cycle: Plan (backlog refinement with BDD) → Act (sprint execution on the shared board) → Check (QA agents verify, humans review) → Adapt (sprint data informs the next cycle).

In-App AI Chat (v0.4.0)

The v0.4.0 release added a project-level AI chat that lets you plan work and manage the backlog in plain English. Chat with AI agents to create or update epics, stories, tasks, and documentation — all without leaving the board. The AI drafts items directly into the backlog with proper structure, ready for refinement.

Activity Diff & Revert (v0.4.0)

Every field change in Paca's activity pane shows a before/after diff. One click reverts any change to its previous value — whether the change was made by a human or an AI agent. This safety net means teams can let agents move fast without fear of unrecoverable changes.

MCP Server — Connect Any AI Agent

Paca ships an MCP (Model Context Protocol) server published as @paca-ai/paca-mcp on npm. It gives any MCP-compatible AI agent structured access to projects, tasks, sprints, documents, members, views, custom fields, attachments, activity, and comments. No scraping, no custom APIs.

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

Connect Claude Desktop, Claude Code, or any MCP client and ask questions like "List all active sprints in project X" or "Create a task for implementing OAuth and assign it to sprint 3".

Claude Code /paca Skill Set

For teams using Claude Code, Paca provides a set of 10 slash commands that let you manage the entire workspace in plain English without leaving your editor:

Each command reads your Paca documentation first — so output matches how your project actually works. The skills use the Agent Skills open standard (SKILL.md format) and are installable via a one-liner script.

WASM Plugin System

Paca's plugin system uses WebAssembly for backend plugins and standard module bundles for frontend. Write backend plugins in Go, Rust, AssemblyScript — anything with a WASM target. Plugins run in a sandboxed environment with a capability-based permission model: they declare exactly which host functions they need, and nothing more.

The Plugin Marketplace inside the Paca UI lets you browse and install community plugins without touching the command line. Go to Settings → Plugins → Marketplace, find a plugin, and click Install.

Unified Scrumban Board

Humans and AI agents share a single real-time board powered by Socket.IO . No separate "AI workspace" or "agent mode" — everyone sees changes the moment they happen, with live presence cursors showing who (or what) is working on what.

OpenHands-Powered AI Agents

Paca's AI agents run on the OpenHands SDK, each executing inside its own isolated sandbox container. The agent environment is completely separated from the host — agents can write code, run commands, and manipulate files without touching the Paca server or your infrastructure.

Architecture

Paca runs as a multi-service stack managed via Docker Compose :

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/ai-agent Python + FastAPI + OpenHands SDK — AI agent orchestration
apps/e2e          Playwright — end-to-end test suite
skills/           Agent Skills — /paca slash commands for Claude Code

PostgreSQL        Persistent store
Valkey            Cache + async event streams between services

Key architectural decisions:

• Go API with Gin handles the core domain logic — projects, tasks, sprints, documents, members. It's the single source of truth.
• Valkey (the open-source fork of Redis) serves as cache and event stream between services, enabling real-time updates via Socket.IO from the Node.js realtime service.
• The MCP server (apps/mcp) is a standalone npm package that translates MCP tool calls into REST calls against the Go API. Any MCP client can connect.
• The AI agent service (services/ai-agent) runs Python with FastAPI and the OpenHands SDK. Each agent gets its own sandbox container — isolated from the host and from other agents.
• PostgreSQL is the only persistent store. MinIO provides S3-compatible storage for attachments (optional — can use AWS S3 instead).
• Nginx acts as the API gateway, routing traffic to the appropriate service.

Services are independently scalable. Teams can scale down components they don't need: run without the AI agent service to reduce resource usage, or connect to an external PostgreSQL instead of the bundled one.

Integration with AI Coding Agents

Paca was designed for AI agent collaboration. The integration strategy operates at three levels:

1. MCP Server (Protocol Level)

The @paca-ai/paca-mcp npm package implements the Model Context Protocol, giving any MCP-compatible agent structured CRUD access to the entire Paca data model. Tools are organized by domain:

• Projects: list, get, create, update, delete
• Tasks: list, get, create, update, delete, reorder, change status
• Sprints: list, create, update, complete
• Documents: list, get, create, update, delete
• Members & Roles: list, add, manage permissions
• Views & Custom Fields: create views, define custom fields
• Activity & Comments: read activity, add comments

Plugins can register additional MCP tools at runtime, extending what agents can do.

2. Claude Code Skills (Editor Level)

The /paca skill set for Claude Code provides natural-language management of the entire workspace. A PO can say /paca-epic "Implement OAuth login with PKCE flow" and Claude Code creates the epic, generates child stories, writes a BDD spec, and posts everything to Paca — all without leaving the editor.

3. OpenHands Agent Runtime (Execution Level)

Paca's built-in AI agents run on OpenHands, a generalist AI agent SDK. This means agents can execute code, run tests, generate documentation, and interact with the filesystem — all inside sandboxed containers. The results are posted back to the Paca board as task updates, comments, and document changes.

This three-layer approach maps directly onto Paca's P-A-C-A cycle: the MCP layer provides structured data access for planning (Plan), Claude Code skills let agents execute tasks and produce artifacts (Act), and the OpenHands runtime generates results that the team reviews on the shared board (Check), feeding into the next sprint (Adapt).

Use Cases

AI-Augmented Scrum Teams

A development team adopts Paca to bring their AI coding agents into the Sprint process. The PO collaborates with an AI agent to write BDD specs during sprint planning. The AI agent picks up implementation tasks from the board, works through them, and updates status — all visible to the team on the same Scrumban board. QA agents run verification tasks while humans review the output. The bot gains a full sprint retrospective with data from both human and AI contributors.

Product Owners Who Want BDD Help

A PO writes high-level requirements in Paca. An AI agent (connected via Claude Code) asks clarifying questions using /paca-clarify, then generates Gherkin scenarios that the PO refines. The resulting BDD specs are stored as documents in Paca, linked to the relevant stories, and accessible to the entire team.

Self-Hosted AI-Native Team Collaboration

A team replaces their $15/seat/month Jira instance with Paca, gaining AI-native collaboration that no cloud tool can match. They run it on their own infrastructure behind their own firewall — no data leaves their servers — while AI agents work alongside humans on the same board, assigned to sprints and collaborating on tasks. The self-hosted model means they control the AI agent runtime, choose their own LLM providers, and never pay per-seat for either humans or AI teammates.

Pricing

Paca is free forever — no subscriptions, no per-seat pricing, no feature gates.

The only costs are:

• A Linux server with Docker (any cloud VM, VPS, or on-premise machine)
• LLM API keys if you use Paca's built-in AI agents (you provide your own model access)

No enterprise tiers, no premium plugins, no paid upgrades. The project is funded through community contributions and maintainer effort.

Getting Started

One-Command Install (Recommended)

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.

Manual Docker Compose

# 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 nginx
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/gateway.conf -o nginx/gateway.conf

# Create your environment file with secure credentials
cat > .env <<'EOF'
JWT_SECRET=<run: openssl rand -hex 32>
ADMIN_PASSWORD=<your-admin-password>
POSTGRES_PASSWORD=<run: openssl rand -hex 32>
AGENT_API_KEY=<run: openssl rand -hex 32>
INTERNAL_API_KEY=<run: openssl rand -hex 32>
ENCRYPTION_KEY=<run: openssl rand -hex 32>
PUBLIC_URL=http://localhost
EOF

# Start the stack
docker compose --env-file .env up -d

Open http://localhost — log in with admin and the password you set.

Connect Claude Code

# Install the Paca skill set
curl -fsSL https://raw.githubusercontent.com/Paca-AI/paca/master/scripts/install-claude-skill.sh | bash

# Connect the MCP server
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 Claude Code for guided setup
# Then start managing your workspace:
# /paca-sprint
# /paca-epic "Add rate limiting to API"

Upgrading

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

Database migrations run automatically on API startup.

Comparison

Paca is the only project management tool designed specifically for human-AI collaboration on a Scrum board. Here's how it compares to alternatives:

Paca is not a replacement for Jira in large regulated enterprises — yet. It is an early-stage project (v0.4.3) with a small community and limited ecosystem. What it offers instead is a different approach to AI collaboration that no established tool provides.

Choose Paca when: you want AI agents as genuine participants in your Scrum process, you prefer self-hosted infrastructure, and you're comfortable with early-stage software.

Choose Jira/Linear when: you need enterprise maturity, compliance certifications, a large plugin ecosystem, and a managed cloud solution.

Further Reading

• Paca GitHub Repository — Main project with README, architecture docs, and getting started guides
• Paca MCP Server Setup — Full MCP configuration reference and available tools
• Claude Code Skill Documentation — All 10 /paca slash commands with examples
• Paca Architecture Overview — System architecture, service responsibilities, and data flow
• Paca Plugin System — WASM plugin development, capability permissions, and marketplace
• Paca Roadmap — Upcoming features and project direction
• OpenHands SDK — The AI agent runtime powering Paca's agent execution
• Agent Skills Specification — The open standard used by Paca's Claude Code skills