Claims, not evidence
The agent says the tests passed. Nobody ran them where it counts.
Autonomous software delivery
From request to main.
Autonomous, with evidence.
Cellvoy takes a Jira epic from a raw request all the way to merged code on main. Every rule that matters is enforced in code, every claim is backed by a real run, and an independent QA Agent decides what ships.
- Request
- Epic
- Tickets
- QA
- main
The problem
Coding agents write fast. Delivery still runs on people.
Collisions at scale
Parallel agents touch the same files. Branches drift and conflict.
A manual last mile
Review, integration and the call to merge into main still eat senior engineers’ days.
The insight
The bottleneck isn’t the model. It’s the missing process.
Trustworthy autonomy = rules enforced in code + evidence from real runs + independent review.
What Cellvoy is
Four agents. One code layer that holds the keys.
Analyst
BA Agent
Turns a raw request into a PRD, an epic and tickets.
Writer
Implementer
Writes each ticket in its own isolated worktree.
Checker
Reviewer
A different, read-only model checks every acceptance criterion.
Gatekeeper
QA Agent
Decides whether the finished epic is fit for main.
Code layer: Git, validation and delivery. The only part of Cellvoy that commits, pushes, opens pull requests and merges.
End to end
From a request to main, in one flow
Request
A stakeholder need, in plain words.
BA Agent
PRD, Jira epic, tickets and the epic branch.
Ticket loop
Plan, reserve, implement, review, validate, merge into the epic.
QA Agent
One verdict on the whole epic.
main
Merged, with the evidence attached.
Human decision 1: approve the ticket list, then press Start.
Human decision 2: sign off only when QA asks for it.
BA Agent
From a vague request to a ready-to-run epic
- Reads before it asks. Every repo in the project plus the chosen Confluence spaces.
- Asks for decisions, not forms. Findings come with sources; the analyst picks.
- Pushes back with evidence. Conflicts between the request, the docs and the code are shown, never silently resolved.
Ticket loop
Run the whole epic in parallel, without collisions
- Plan
- Reserve files
- Implement
- Review
- Validate
- Deliver
Isolated worktrees
Each ticket gets its own Git worktree and branch, cut from the epic branch.
File reservations
Two tickets never write the same file at once. Overflow is caught in code.
Capacity and resume
Concurrency limits per host and project. Sessions resume from their last stage.
Separate roles
The writer never grades its own work
planner model
Manager
Plans the ticket, names the files to reserve, runs the rounds.
developer model
Implementer
Edits only the reserved files on the prepared ticket branch.
a different model, enforced
Reviewer
Read-only. Sees the acceptance criteria and the real diff, not the implementer’s story. Returns MET or MISSING per criterion, with evidence.
The outcome contract is strict and fail-closed: malformed or inconsistent output never passes.
Evidence
Proof comes from real runs, not from the agent
- Validation
- Your repo’s own build and tests, run in its devcontainer.
- Red run
- Fed back to the same session; after 3 attempts the ticket stops with its reason.
- Read-only
- Validation can’t change the repo; git state is checked before and after.
- Audit trail
- Every prompt, output, result and decision is stored as an artifact.
- Pull requests
- Descriptions are built from those artifacts, not from a model’s story.
“Tests passed” is never taken on trust. Before delivery the code layer re-checks the PASS outcome and green validation.
Safety
Guardrails live in code, not in prompts
Agents can’t touch history
No commit, push, merge or rebase. HEAD is compared before and after every agent call.
Protected branches refused
Work on main, develop, release or hotfix branches is rejected outright.
One delivery path
Commit, push, pull request and merge happen in one resumable, idempotent step.
No secret leakage
Tokens and credentialed Git URLs never reach logs. Secrets are stored encrypted.
New · QA Agent
The last gate before main
Looks at
The epic and its blast radius
Everything the epic changed, plus the code that calls it and that code’s tests.
Against
Intent and fresh evidence
Acceptance criteria, the PRD, and validation re-run on the tip of the epic branch.
Produces
Blocking vs. backlog
Blockers become follow-up tickets on the same epic. Old debt goes to the backlog and never holds the merge.
Missing tests become findings, not QA-written code. Every epic leaves tests behind, so your regression suite grows with each one.
How QA decides
- Blocking findings, rounds leftFollow-up tickets open on the same epic; the loop fixes them and QA runs again.
- Blocking findings after 3 roundsHanded to a human to approve or reject.
- Clean, touches sensitive pathsWaits for human sign-off; who approved, and when, is recorded.
- CleanMerged into main automatically.
A “clean” verdict never merges over red validation. Sensitive paths (auth, payments and so on) are set per project.
Onboarding
Getting a repo ready is one pull request
- 1
Inspect
Cellvoy reads the repo and works out how it builds and tests.
- 2
Generate and prove
Adds the validation recipe, devcontainer and agent instructions, then proves they run.
- 3
Your team merges
Delivered as a pull request to review. Cellvoy never merges it itself.
“We onboard working repos. We don’t repair broken ones.”
Integrations
Fits the stack you already run
Work tracking
Jira · Confluence
ClickUp as a read-only task source.
Code hosting
GitHub · GitLab · Bitbucket
Pull and merge requests.
Feedback
Back in Jira
Status transitions, results and stop reasons on the issue.
Models
Bring your own
OpenAI, Anthropic, DeepSeek, Kimi, GLM and more. A model per role, chosen per project, with cost tracking per run.
Deployment
SaaS or on-prem
Managed by us, or run inside your own infrastructure.
Positioning
A delivery platform, not a coding assistant
| Dimension | IDE assistants | Single-agent AI devs | Cellvoy |
|---|---|---|---|
| Unit of work | Lines and files | One ticket | The whole epic, to main |
| Runs on | A developer’s laptop | The vendor’s cloud | SaaS or your infrastructure |
| Evidence | The agent’s word | The agent’s word | Real validation runs |
| Review | A human | The same agent | Separate reviewer + QA Agent |
| Parallel work | None | Limited | Capacity + file reservations |
| Git control | In the agent’s hands | In the agent’s hands | Code layer only |
| Merge to main | A human | A human | QA Agent, human on sensitive code |
Proof
Cellvoy builds Cellvoy.
The QA Agent itself was delivered by Cellvoy’s own ticket loop: every backend and admin ticket ran in its own worktree and merged into the epic branch without a human touching Git.