Introduction to PhillipCLI
PhillipCLI is a platform that helps software teams use AI agents in one shared way that is controlled and measurable. After reading this page, you know what the platform includes and how a task moves through it. Then you pick your role at the bottom of the page to get started.
Why a platform?
Every team that starts using AI agents runs into the same problem. Each person writes their own prompts and installs their own tools, so one person's workflow can't be reused by another. Agents run on your machine with your permissions, so everyone worries about an accidental delete command or a secret file being read and sent out. And at the end of the quarter, when the boss asks how much AI helped and what it cost, nobody has the numbers.
PhillipCLI addresses exactly these three points. The whole team shares one set of approved resources. Agents work in an area that someone watches. And every task leaves metrics behind, so you can see where AI helps.
The four parts of the platform
The platform has four parts, and each one does one job.
Swipe sideways to see the whole diagram.
Tara is the shared place. It's the store of skills, agents, kits, and harnesses that have passed automated checks and human review, and are digitally signed before anyone installs them. Tara also handles sign-in and organizations (members, roles, and projects), and it has a web Portal where people discover resources, review submissions, and view projects. Tara runs online and is shared: each organization sees only its own data.
Phillip is the part for the people doing the work. It's the ph command plus a VS Code extension, and it runs on your machine. Phillip installs resources from Tara, opens Claude Code with the project's exact configuration, and picks up tasks for you. Guardrails also lives in Phillip: it watches for dangerous commands and sensitive data before the agent can touch them.
Bandum closes the loop of assigning work and acceptance. A task is an issue, a status is a label, and test cases and test results are files in the repo. Bandum is the interface and the commands for working with all of that. Devs and Testers use Bandum on their machines, while BAs test directly on the Bandum website.
Ryoma measures results. It collects delivery progress and AI cost into dashboards for each organization's projects, and sends a weekly digest to the project's contacts. Ryoma runs online alongside Tara.
In short, Devs and Testers use Phillip and Bandum on their machines. BAs, POs, and PMs need only a browser to reach Tara.
How does a task move through the system?
Follow a real task, for example adding a change-password feature to acme/shop-web.
Swipe sideways to see the whole diagram.
The BA opens the project's GitLab (or GitHub) and writes an issue that lists the acceptance criteria (AC): the password changes when the user enters the correct old password, and an error appears when the new password is too short. The issue carries labels for the work type and size, so Ryoma knows how to count it.
The dev opens a terminal in the repo and runs ph bandum start GH-12. Phillip picks up the task, creates a branch, and scaffolds the test cases, with one entry per AC waiting for the dev to fill in. The dev works with Claude Code as usual. The agent runs in the project's safe area, and Guardrails stands beside it and watches commands. When the agent tries to run a command that is too risky, Guardrails blocks it and states the reason, so the dev doesn't have to guess.
When the work is done, the dev runs ph bandum verify GH-12 to check each test case automatically, opens a PR with ph bandum pr GH-12, and moves the task to testing with ph bandum review GH-12. Bandum changes the status label itself, so the dev doesn't have to set it.
The BA picks up the task in the awaiting-testing column, opens the task page on the web, and marks each test case Pass or Fail. For each failing test case, the BA describes the bug. If every test case passes, the BA clicks Approve. Otherwise, the BA clicks Send back, and the task returns to the dev to fix and then re-enter testing.
As soon as the task is done, Ryoma records the time from start to finish, the number of times it was sent back, and the AI cost spent on the task. On Monday morning, the PM receives a weekly digest that summarizes those numbers for the whole project.
The details of each step, including when a task is sent back, are in Task lifecycle.
What principles does the platform follow?
Source code and operations stay on your machine. Phillip and Bandum push data up on their own initiative, and the online services never call back into your machine. What gets sent is listed in Data collected.
Every resource is reviewed and signed. Tara signs only after a resource passes automated checks and a person approves it, and Phillip verifies the signature before loading. So what runs on your machine is exactly what was approved.
Measurement exists to improve the process, not to grade individuals. Metrics are computed per project and per workflow. Per-person figures serve only cost quotas, and only that person and the administrators can see them.
Finally, the platform integrates through plugins and isn't tied to one vendor. To connect a tool, you write a kit for it, and Phillip's core contains no vendor-specific code.
What does it support today?
Claude Code is the main AI coding tool, and Tara's resources install into it like any plugin. For code hosting, the platform works with GitHub and GitLab. For work management, Jira connects through the tracker kit, and reading tasks from Jira for Ryoma is planned.
Some directions aren't available: using an AI coding tool other than Claude Code, running self-hosted models, or a dedicated evaluation suite for agents. These are only under consideration, not commitments. What's in progress, coming soon, or under consideration is all listed in the Roadmap.
Ready to start?
Choose your entry point by the work you do. To understand in detail how the parts connect, read Architecture next.