Model or dataset
Paca-AI/paca avatar
Paca-AI/paca

Paca ships WebAssembly plugins with a capability model, and bills plugins in the comparison table

AI-native, free, open-source alternative to Jira, Trello, ClickUp & Monday. Built for Scrum teams where humans and AI agents collaborate as equals — on the same board, the same sprints, the same goals. Self-hosted. Fully customizable via config and plugins.

2,092 stars205 forksGoApache-2.0

At a glance

What is it?
A self-hosted project management tool whose pitch is that AI agents sit in the same Scrum team as people. The plugin system is the serious engineering: WebAssembly modules that declare exactly which host functions they want. The comparison table against the incumbents is where the pitch gets thin, and the same document contains both.
Who is it for?
Paca is worth evaluating if you want agents to hold tasks in your tracker rather than sit in a chat window beside it, and the sandbox design is the part that makes that credible rather than reckless. Two cautions.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • Paca-AI/paca2,092 ★ · +283
Star history
Repository2026-09-112026-11-21
Paca-AI/paca1.8k2.1k

283 Stars in the last 71 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Backend plugins are WebAssembly modules that declare their own permissions

The plugin system is the part of this project that deserves the most attention, and the README is specific about how it works.

Backend plugins compile to WebAssembly, and the stated requirement is deliberately broad: write in Go, Rust, AssemblyScript, or anything with a WebAssembly target. Frontend plugins ship as ordinary module bundles instead.

The security model is the interesting sentence. Plugins run sandboxed under a capability-based permission model, and each plugin declares exactly which host functions it needs and nothing more.

That is a meaningful design choice. A capability model inverts the usual plugin assumption: instead of a plugin running with the host's authority and being trusted, it starts with nothing and asks for specific capabilities by name. A plugin that needs to read tasks declares task reading; one that has no business touching the database never obtains a database handle.

For a project whose entire premise is that untrusted and semi-trusted agents will be running inside it, that model is load bearing. Everything about how agents get work done depends on plugins not being able to reach past the surface they asked for.

Agents hold tasks, which is the actual product claim

The stated idea is that agents should participate in the Scrum process rather than generate output in isolation, and the README lists five things that means in practice.

Agents are assigned to sprints and appear on the board beside human teammates. They pick tasks up from the backlog and update status in real time. They help product owners and analysts write Gherkin scenarios. They contribute to system design documents so architecture stays visible to the whole team. And they respond to emerging complexity the way a person would.

The framing is that this is not automation, and the README grounds the claim in a named sense-making framework, arguing that complex domains require teams rather than pipelines.

The functional core of that is the first two bullets. An agent that holds a task and updates its status is doing something categorically different from an assistant you paste a prompt into, because the state lives in the tracker where a human can see it. The remaining bullets are softer, and the difference matters: helping write a specification is a suggestion, while holding a card is a commitment with a status change.

The comparison table prices competitors from the outside

The document contains a side-by-side table against four named products, and it is the weakest content on the page.

Two rows are claims that cannot be checked by the reader. Cost is given as a per-seat monthly range for the incumbents against free forever for this project, with no version, date or tier named for the comparison. Customization is described as limited and locked behind enterprise tiers for them, and as fully open for this one.

A third row is categorical. Source is listed as closed or proprietary for the incumbents, which is not accurate for all four products named in the same document.

The hosting row is the one that survives, and it is genuinely different: vendor cloud with their servers, against self hosted where you own everything. That is a real architectural distinction rather than a marketing one.

The rest of the table is positioning. It is not dishonest so much as unmeasured, and a reader evaluating a tracker replacement should discount it entirely while taking the plugin architecture and the hosting model seriously.

Routing to the right agent is delegated to a third-party decision engine

A recent release adds an integration with an external AI decision engine, and the design choices in it are unusually well specified.

It is opt in and per project, and you bring your own key, either for the default provider or a compatible alternative. The key is encrypted at rest and never shown again. Most importantly, a project without a key behaves exactly as before, which is the correct way to add a dependency to a system that already works.

Four capabilities are built on it. An auto setting in the chat's agent picker hands a message to the best fit agent based on each agent's description. Task creation can auto fill fields left blank, applying only confident answers and never overwriting a field a person set. A task assignee can be set to auto, in which case the engine picks the best matching member, and if it is not confident it leaves the task unassigned and explains why in the activity feed. Finally there is a condition node for automations that routes on the engine's answer and falls back to an else branch whenever it is unsure or unavailable.

The pattern is consistent: the engine proposes, the human's explicit input wins, and uncertainty routes to the safe branch. That is the right shape for this kind of feature and it is worth noting that the fallback is specified rather than implied.

The cycle borrows both Scrum and the scientific method

Collaboration is structured around four phases, and the README says they mirror Scrum and the scientific method at the same time.

Plan is where product owners, analysts and agents refine the backlog together, writing scenarios and designs jointly. Act is the live sprint, where humans and agents pull from the board, execute and post updates. Check is where automated verification runs, humans review what agents produced, and the board is expected to reflect reality. Adapt feeds the sprint's data into the next cycle, with the team retrospecting together, human and agent alike.

That is a reasonable four-phase structure and the mapping is honest, with no attempt to pretend the phases are novel.

The Check phase is where the design has real content. Automated verification running alongside human review, with the board as the shared state, is the mechanism that makes the whole premise workable. Without it, an agent's output has no reviewable artefact and the board drifts from reality, which is the failure the phase is named after.

The configurable part is worth noting alongside this: workflows, statuses, field definitions, board layouts, sprint rules and agent behaviour are all driven by project level configuration files, with no code needed.

Configuration covers the process, plugins cover the code

The customisation story splits into two mechanisms, and keeping them separate is what makes the project tractable.

Configuration handles the things that differ between teams using the same process: workflows, statuses, field definitions, board layouts, sprint rules and agent behaviour. All of it is driven by project level files, and the stated promise is that adapting the tool to a team's process needs no code.

Plugins handle everything else. They can extend or replace any part of the system, not merely add to it, and the directory layout separates backend modules, which are WebAssembly and can add routes, logic and data models, from frontend modules, which add pages, board views and widgets.

Installation comes from a marketplace inside the interface, reached through settings, with no command line involved, and there is a shell script for installing from the filesystem during local development:

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

The split means a team can adopt this by editing configuration files and never write a plugin, which is the realistic path for most adopters. It also means the WebAssembly sandbox only matters to the smaller set of teams that do write plugins, which is a good ratio for a security model to be optional in.

A small core with a monorepo, a roadmap file and three agents in the nav

The repository layout is modest for a product of this scope. Alongside the usual governance files and a licence, there is a roadmap document, and then four directories: applications, deployment, documentation, and services. Plus a scripts directory.

There is no test directory at the root, which is worth noting given the plugin system accepts arbitrary WebAssembly. Tests may live inside the individual directories, but the visible layout does not show them, and that is the first place I would look before trusting a plugin host with untrusted code.

The navigation at the top of the page points to five destinations: getting started, an MCP server for connecting any AI agent, Paca skills aimed at several coding tools, the architecture document, contributing, and the roadmap. So the agent integration story has three separate surfaces, a protocol server, a set of skills, and the agents themselves as first-class board members.

Release numbering is on a two-part scheme in the visible history, with patch releases on consecutive days. The README's newest-features section is labelled for a version behind the latest release, which is a small editorial lag rather than a discrepancy, since it simply has not been retitled.

Editorial conclusion

Paca is worth evaluating if you want agents to hold tasks in your tracker rather than sit in a chat window beside it, and the sandbox design is the part that makes that credible rather than reckless. Two cautions. The comparison table prices the incumbents and their limits from outside, so treat the cost and customization rows as positioning rather than measurement. And the AI routing layer that decides which agent gets a message is a third party service you supply a key for, so the agent that picks the agent is outside your deployment even though the agents are inside it.

Frequently asked questions

What is Paca?

It is a self-hosted project management platform built around the idea that AI agents should be Scrum team members rather than chat assistants on the side. Agents are assigned to sprints, appear on the board beside people, pick tasks from the backlog, update status in real time, and help write specifications and design documents. It is licensed Apache 2.0.

How do plugins work in Paca?

Backend plugins compile to WebAssembly and can be written in Go, Rust, AssemblyScript or anything with a WebAssembly target, while frontend plugins ship as standard module bundles. Plugins run sandboxed under a capability-based permission model, declaring exactly which host functions they need. They can be installed from a marketplace inside the interface or from the filesystem with a script.

Does Paca need an external AI service to route tasks to agents?

Only if you turn it on. The decision engine integration is opt in and per project, and you bring your own key, which is encrypted at rest and never shown again. A project without a key behaves exactly as before, and when the engine is unsure it falls back rather than guessing.

Can I change Paca's workflow without writing code?

Yes. Workflows, statuses, field definitions, board layouts, sprint rules and agent behaviour are all driven by project level configuration files. Plugins are the separate mechanism for changing what the software can do, and the README frames those as optional.

How does Paca compare to Jira, Trello, ClickUp and Monday?

The README presents a table contrasting them on AI integration, collaboration model, hosting, cost, customisation, weight and source. The hosting distinction is real, since those four are vendor-hosted while Paca is self-hosted. The cost, customisation and source rows are the project's own positioning and are not measured against a named version or tier.

Official sources

  1. License: Apache-2.0
  2. Paca-AI/paca on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/paca-ai-paca.svg)](https://hysenlabs.com/projects/paca-ai-paca)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/paca-ai-paca.svg)](https://hysenlabs.com/projects/paca-ai-paca)

Was this useful?