The pitch sounds almost tongue-in-cheek until you realize they're serious. If an AI agent is writing code, fixing bugs, or generating documentation on your team, shouldn't it show up on the same Kanban board as everyone else? Not as a helpful chatbot in the corner. As an actual teammate—with assigned tickets, sprint commitments, and a status that everyone can see.
That's the wager behind Paca, a new open-source project management tool that's been making quiet waves in developer circles. The project made its debut earlier this year and quickly accumulated over 850 GitHub stars and a lively Hacker News discussion—garnering 163 points and 58 comments—that veered between enthusiasm and existential dread about what it means to manage machines the way we manage people.
"No sidebar chat widgets or bolt-on assistants," the documentation declares, perhaps a bit defiantly. "Actual teammates."
It's a premise that feels either self-evident or slightly absurd depending on where you sit. But for teams already deploying AI agents to handle routine development tasks—and there are more of those than you might think—Paca's marketing material positions it as something practical: a way to track what your bots are doing without inventing an entirely separate workflow.
The Mechanics of Mixed Teams
Strip away the conceptual novelty and you're left with a reasonably conventional Scrumban board. Real-time updates, drag-and-drop tickets, sprint planning. The architecture borrows liberally from the established playbook: React on the front end, Go and Node.js services on the back, PostgreSQL for data, Socket.IO pushing live changes to browsers.
What distinguishes Paca is execution environment. Human developers work in their usual IDEs, commit code, move cards. AI agents—integrated through the OpenHands SDK—run in isolated sandbox containers, execute tasks programmatically, update their own status. Same board, different runtime.
The early version released this year introduced a feature that reveals the team's assumptions about how this will actually work: activity diffs with one-click revert. When an agent changes a field you didn't want changed, you don't dig through audit logs or manually fix it. You just undo. It's the kind of guardrail you build when you expect mistakes—and expect them often.
There's also built-in support for behavior-driven development scenarios written in Gherkin, plus system design documents that live alongside tasks rather than buried in Confluence somewhere. Documentation as a first-class citizen, not an afterthought.
Why It Might Actually Matter
Paca positions itself as a free, self-hosted alternative to Jira, Monday, ClickUp, and the rest of the enterprise project management ecosystem. Those tools typically charge somewhere between $8 and $20 per user per month. When "users" might include a dozen AI agents running autonomously—a scenario Paca's positioning against vendor pricing models highlights—the math gets uncomfortable fast.
The self-hosting angle matters for another reason. Teams building with AI agents often handle sensitive codebases or proprietary data—precisely the kind of information they'd rather not pipe through a vendor's infrastructure. Paca's technical stack allows for on-premises deployment with external Postgres, S3-compatible storage, or scaled-down configurations that disable features you're not using.
The pricing model is blunt: $0 forever. No seat limits, no feature gates. Whether that's sustainable long-term is unclear—based on the lack of public information about team size or structure, the project appears to be maintained by a small team operating under the handle "pikann" on GitHub. No venture funding announcements. No disclosed team size. Just open-source software solving a specific problem.
The Plugin Architecture (and Why WASM)
Here's where things get technically interesting. Paca's plugin system compiles extensions to WebAssembly and runs them in a sandboxed environment with capability-based permissions. Backend plugins can extend API logic; frontend modules inject UI components.
Why WebAssembly? Performance, mostly, but also isolation. Plugins can't casually reach into the database or make arbitrary network calls. They get explicit permissions. The repository ships with three official plugins—GitHub integration, BDD collaboration tools, checklists—and includes a marketplace UI for discovering others.
It's the kind of architecture decision that signals ambition beyond a niche tool. WASM plugins keep the core lightweight while enabling heavy customization without forcing users to fork the entire codebase. Whether the plugin ecosystem actually materializes is another question.
Claude in the Terminal
Perhaps the most telling integration involves the Model Context Protocol—a specification that lets AI agents interact with external tools through standardized interfaces. Paca ships an MCP server as an npm package that exposes 81 tools across 16 categories to compatible agents like Claude Desktop and Claude Code.
For developers using Claude Code specifically, Paca provides custom slash commands that treat Paca artifacts as first-class citizens. Commands like /paca-sprint or /paca-estimate let you orchestrate work directly from the editor. Task management becomes a command-line interface, which feels native if you already live in the terminal.
The setup is straightforward enough—install a package, point it at your Paca instance, add a config block. The intent seems clear: meet agents where they already work rather than forcing them into a separate browser UI.
It's a small design choice that reveals a larger philosophy. If AI agents are going to be teammates, they need tools that respect how they operate, not just how humans do.
What Happens Next
The public roadmap—visible on GitHub—shows Phase 1 largely complete: single-command install, Scrumban boards, version-controlled docs, the WASM plugin system, MCP packaging, agents-in-sprints. Phase 2 plans ARM64 support, a Helm chart for Kubernetes, OAuth tokens, Slack and GitLab hooks, sprint intelligence metrics. Phase 3 targets role-based access control, audit logs, single sign-on, performance tuning. A proper v1.0 release, in other words.
Post-1.0 explorations mention multi-agent orchestration and—perhaps inevitably—an optional hosted cloud offering. Which would be ironic, given the entire pitch hinges on self-hosting and avoiding vendor fees. But pragmatism has a way of winning these arguments.
The early Hacker News discussion revealed the usual mix of technical curiosity and sustainability skepticism. How do you fund something that's free forever? What's the security model for plugins? How does this compare to Linear or Shortcut or any of the other Jira alternatives that launch every quarter?
A commenter in the thread noted that the GitHub security advisories link returned a 404. Small detail, maybe, but the kind of thing that matters when you're asking teams to trust your software with their project data.
A Bet on the Future (or Present)
It's tempting to dismiss Paca as a solution in search of a problem. How many teams are really managing AI agents as peer contributors right now? But spend time in developer communities—Discord servers for agentic frameworks, GitHub discussions for autonomous coding tools—and the question starts to feel less hypothetical.
Teams are already running agents that open pull requests, triage issues, generate tests, refactor legacy code. The workflows are messy, duct-taped together with custom scripts and manual oversight. What Paca offers is structure—a way to formalize what's already happening in an ad hoc way.
Whether that structure is premature or prescient depends entirely on how quickly AI agents move from experimental to routine. Paca's making a bet that the shift happens sooner than the incumbents expect.
The software is still early—version 0.4.x as of mid-year, with username validation fixes and MCP adjustments shipping regularly. But the architectural choices suggest a team planning for production use, not just a weekend side project.
If nothing else, it's a useful signal of where developer tooling might be headed. Not AI as assistant. Not AI as copilot. AI as colleague—with all the workflow implications that entails.
And maybe that standup meeting really is about to get a lot more crowded.
