Skip to content

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.

Architecture diagram. On your machine: Phillip, Claude Code with Guardrails, and Bandum. Online: Tara, Ryoma and Grafana. GitHub or GitLab holds the source data. Your machine pushes data out; online services never call back into your machine.On your machineOnlinePhillipph CLI and VS CodeClaude CodeGuardrails vets commandsBandumTask board, testingTaraResource library, PortalRyomaFlow and AI metricsGrafanaInternal ops dashboardsGitHub or GitLabSource of truth: issues, labels, PRs, testcase filesruns via phInstall resources, sign inFiltered telemetrydashboardsTasks, labels, test filesReads task progress

Swipe sideways to see the whole diagram.

Arrows show the direction data moves. Phillip and Bandum call out; online services never call back into your machine.

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.

The journey of a task across five lanes. The BA writes an issue with acceptance criteria. The dev picks up the task with ph bandum start, the agent works under Guardrails, then the dev runs verify, opens a PR and moves the task to testing with review. The BA tests for acceptance, then approves (Duyệt) or sends the task back (Trả lại). If sent back, the dev runs fix and returns to the agent. After approval the task is Done, Ryoma records metrics and sends the PM the weekly digest.BA / PODev and agentGuardrailsBandumRyoma / PMWrite issueAC, labelsPick up taskph bandum startCreate branchtest scaffoldAgent worksuses Claude CodeGuardrailsblock, mask,and logAuto checkph bandum verifyOpen PRph bandum prMove to testingph bandum reviewChange labelstatus: reviewTestingacceptanceSend backa TCfailedApproveall TCs passDoneissue closedLog metricsFlow andAI costWeekly digestsent to PMMonday morningFailPassph bandum fix

Swipe sideways to see the whole diagram.

When a task is sent back, the ph bandum fix loop repeats until the tester approves. Bandum changes the status label at each step.

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.

The Bandum board shows the whole team where each task stands, taken from issues on GitHub or GitLab.

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.