Multi-agent · Whole team · In development 2026 · Reza Ilham

CatAgent

About this note

A pipeline for a product team that already lives in Jira. Humans approve the plan first, agents write the tests and code onto a branch, and the assigned engineer reviews it before opening a pull request.

Chapter 1

Keep Jira as it is

Picture a product team: iOS, Android, backend, a tech lead, a solution architect, and QA. Their backlog already lives in Jira. CatAgent connects to that Jira project and its code repositories without asking anyone to learn a new board or move their tickets somewhere else.

Chapter 2

Plan in Jira first, code per repo second

One Jira Epic usually spans three different repositories (iOS, Android, and Backend). If a coding agent jumps straight into writing code from a raw PRD, a single wrong assumption breaks three codebases at once.

CatAgent splits the work into two phases. First, at the Epic level, an Architect (SA) agent breaks the PRD into child Jira tickets and a QA agent writes the manual test cases—without touching any code repo. Once a human Architect and Tech Lead approve that plan, the Story level starts in each platform's own repo: a Tech Lead (TL) agent writes the technical spec and unit tests first, and an Engineer agent writes the code to pass them.

01 · Approve the plan in Jira before any agent touches code
1 · Plan in Jira
2 · Human Gate
3 · Write Tests
4 · Write Code
PAY-100 · Epic

Split PRD into stories

Jira only · 0 code changed

Jira (Plan only) no code repo access Git Repo (Code) pipeline/PAY-142 1. Draft tickets & QA plan Waiting for human sign-off before touching repo ✓ Branch pushed
1 · Where this step happens Jira only · Code untouched
location: Jira Epic PAY-100 Architect + QA Agents

Agents read the Epic PRD and split it into platform tickets (PAY-142 iOS, PAY-143 Android, PAY-144 Backend) plus a manual QA checklist. Zero code repositories are touched yet.

2 · Output of this step Draft tickets + QA plan

Created ticket PAY-142 (iOS): Biometric PIN fallback

Created ticket PAY-143 (Android): BiometricPrompt fallback

Created ticket PAY-144 (Backend): Lockout token API

⏸ Paused — waiting for Human Lead to approve plan

Step 1 happens entirely in Jira: agents break the Epic into 3 platform tickets and a QA checklist. No agent touches a code repository until a human approves this plan.

Chapter 3

A branch, not a pull request

When most coding bots finish a task, they immediately open a pull request and tag four teammates to review 1,000 lines of code nobody on the team has ever run. Everyone ends up debugging raw bot output in PR comments.

CatAgent turns automatic PR creation off. When the Engineer agent finishes, it pushes its commits to a side branch called pipeline/PAY-142. The human engineer assigned to the ticket checks out that branch on their laptop, runs it, fixes any rough edges in their own commit, and opens the pull request only when they stand behind the code.

02 · Why CatAgent pushes a branch instead of opening a PR
Without Human Filter Skipped
Engineer Reviews Branch First Clean PR
PAY-142 · Pull Request ✓ Verified by teammate

Biometric PIN fallback

Engineer checked out branch, tweaked 1 line, then opened PR

Team Review Activity · Slack & GitHub Clean Handoff
Review Duration
12 mins
Team Interruption
0 spam alerts
Outcome
Shipped Cleanly
CatAgent never spams the team with raw bot pull requests. It pushes to a branch first so the assigned engineer can test it locally, fix any rough edges, and open the PR themselves.

Chapter 4

Measuring what sticks

Because the agent commits its work first and the human engineer commits their review edits second on the same branch, Git keeps a permanent record of who wrote every single line. That lets CatAgent's Insights dashboard answer four practical questions automatically:

  1. How much agent code survived untouched? If the agent wrote 5 lines and the engineer only changed 1 line before merging, the survival rate is 80% (4 out of 5 lines).
  2. Were the unit tests good? Whether the engineer kept the agent's unit tests as-is or had to rewrite them.
  3. Did it actually save time? How many minutes the engineer spent reviewing the branch before opening the PR.
  4. If a bug appears later, who caused it? Running git blame on any bug fix tells us immediately whether the bug was in an untouched agent line or in a line a human edited during review.
03 · Track which lines came from the agent vs. human edits
80.0% Agent Survival (Untouched)
0% Unit Test Churn
12m Local Review Duration
100% Traceable Bug Attribution
BiometricAuth.swift · Merged Pull Request 4 of 5 agent lines survived untouched (80% survival)
1 ✓ Kept from Agent func verifyBiometric() async throws -> AuthState {
2 ✓ Kept from Agent guard sensor.canEvaluateBiometrics() else {
3 ✎ Edited by Human return try await pinScreen.present(maxAttempts: 3) // human tweaked
4 ✓ Kept from Agent }
5 ✓ Kept from Agent return try await sensor.authenticateUser()
commit c4a91e · CatAgent Line 1 · Untouched
func verifyBiometric() async throws -> AuthState {

Written by the Engineer Agent on pipeline/PAY-142 to conform to BiometricAuthService protocol. Merged with zero human alterations.

Agent Code Kept 4 of 5 lines (80%)

80% survived untouched

4 lines written by the agent were good enough to ship to production without any human edits.

Human Effort 1 line · 12 mins

Only 1 line needed a tweak

The engineer only changed line 3 to set maxAttempts: 3 on the PIN fallback screen.

If a Bug Happens Instant trace

Knows who wrote the bug

If QA finds a bug on line 3 tomorrow, CatAgent knows it came from the human edit—not the agent.

Click the tabs or any line of code above: out of 5 lines, 4 stayed exactly as the agent wrote them (green) and only 1 was edited by the engineer (orange). That gives an 80% code survival score.

Chapter 5

CatBoard

CatBoard helps one engineer run parallel agents on their own machine. CatAgent is the team-wide pipeline on top of the Jira epics they already share. I compare both setups in my research note on human gates.