An agent can take a ticket, change code, and open a pull request. Your team still has to decide what evidence accompanies that change, who accepts it, and what happens when a check fails. Write those decisions into the workflow before you delegate work.
Give each step an owner, each handoff a pass rule, and each failure a next step. Keep the agent’s task bounded. Put human review where judgment or approval belongs.
Map the path from assigned ticket to QA
Write the workflow as states and transitions. Start with a ready ticket, move it to implementation, then to pull request review and QA. After QA, accept the work or return it for fixes. At each transition, name the evidence required and the person or automation allowed to move the ticket.
The OpenProject Agent Engine repository documents one concrete pattern: an engine claims eligible work, starts an implementation run, moves work to review when a pull request exists, and sends rejected work back for a fix. In that implementation, the engine controls status changes rather than the agents. Set up your workflow so a controller or team process owns ticket state while agents report results and attach evidence.
Give each state four fields:
- Entry condition: What must be true before work enters this state?
- Owner: Which person, agent, or automation handles it now?
- Evidence: What must accompany the handoff?
- Exit rule: What exact condition lets the work advance?
Attach the pull request, test results, review outcome, and open questions to the ticket. The next owner can then review the handoff in context.
Define a checkable outcome for every handoff
Give the agent a compact task contract: the requested outcome, scope, required checks, and report format. Ask it to list changed files, checks run and their results, known limitations, and unresolved decisions. The reviewer can compare those details with the ticket instead of guessing at the agent’s intent from the diff.
A controlled pilot described in Software Delegation Contracts: Measuring Reviewability in AI Coding-Agent Work ran 64 agent executions across ten tasks; explicit contracts improved evidence sufficiency in 22 of 30 paired comparisons, while adding 13% agent tokens and 38% wall-clock time.
Before work starts, define a pass. Name the acceptance conditions, required checks, scope limits, and kind of human review. Replace vague gates such as “looks good” or “tests pass” with the exact tests and reviewer questions.
Use a short handoff checklist:
- The change meets the ticket’s acceptance conditions.
- The pull request identifies the ticket and summarizes the change.
- The agent lists required checks and their outcomes.
- The agent names assumptions, incomplete work, and risks.
- A reviewer or QA owner takes responsibility for the next decision.
Treat missing evidence as unfinished work. Ask the agent to provide it or assign a person to decide what evidence the ticket needs.
Automate repeatable checks and reserve human judgment
Run tests, linting, type checks, builds, and policy checks through automation when they have clear inputs and pass-or-fail results. Record each result against the pull request under review. If a check does not run, mark it “not run,” not “passed.” Do not accept the agent’s summary in place of the check result.
Ask a human to judge whether the change fits the ticket, whether its assumptions make sense, and whether the team should accept it. Keep those decisions separate from mechanical checks. A reviewer can also spot a wider issue or reject a change that creates an unacceptable risk.
GitHub’s Review output from Copilot documentation says that when a repository requires pull request approvals, the person who requested the Copilot pull request cannot supply the required approval; another reviewer must approve it before merge. The same documentation calls for inspecting proposed changes before approving GitHub Actions workflows to run on a Copilot pull request branch. In your workflow, name the person who approves permissions, secrets, release actions, and other consequential transitions.
The research paper Human-AI Synergy in Agentic Code Review analyzed 278,790 code-review conversations across 300 open-source GitHub projects and found that human reviewers exchanged 11.8% more rounds when reviewing AI-generated code than human-written code. Give reviewers room to ask questions and send changes back. Track each request until the agent or ticket owner resolves it.
End each human checkpoint with a decision: approve, request a change, or escalate. Record the decision-maker and any open conditions.
Specify the failure path before a run starts
Set the route for each failed check: return the work to the implementation agent, assign it to a person, or stop the run. Define what feedback the agent receives, what evidence it must return, and how many retries your team allows. Name the person who takes over when the agent reaches that limit.
The OpenProject Agent Engine repository describes an “On Hold” state that the engine ignores until a human moves the ticket. If a ticket lacks context, crosses a policy boundary, or has an outcome the workflow cannot verify, move it to a blocked state and assign a person to resolve the issue. Mark the states where automation stops and explain how a person can restart the work.
Write a rule for each common failure:
- Acceptance check fails: attach the failing result and return the ticket with a focused correction request.
- Required check cannot run: mark the work blocked, name the missing dependency or permission, and route it to its owner.
- Agent exceeds scope: stop the run and ask a person to review the out-of-scope changes.
- Reviewer requests a change: send the specific feedback to the implementation step, then rerun required checks on the updated pull request.
- Agent cannot proceed or repeats a failure: stop retries and assign a person to choose the next action.
Some failures call for more context, a revised ticket, or a permissions decision. Set the route before work starts so the team knows who owns the next move.
Pilot the workflow and look for stuck handoffs
Choose one ticket your team considers low risk and suitable for delegated work. Before assigning it, record its acceptance conditions, the agent’s scope, the evidence required at each handoff, and the person who owns review and QA. Keep the first run small enough for a reviewer to inspect from ticket to outcome.
After the run, review the state history with the team. Flag each wait, handoff without enough evidence, check that missed an acceptance condition, and failure that reached the wrong owner. Note where the reviewer needed clarification. Use those observations to revise the workflow before adding more ticket types or permissions.
Track time spent waiting at each handoff, returns for missing or failed checks, retries before acceptance, and reasons tickets enter a blocked state. Define each measure the same way across the pilot. Review the tickets behind the totals and change the rule, task definition, or owner where needed.
After the pilot, keep the evidence fields reviewers use and remove the ones they ignore.
Start with one ticket
Build the workflow around owned handoffs, checkable outcomes, and clear failure routes. Automate repeatable checks. Keep human attention for decisions that need context, risk judgment, or authority.
Choose one low-risk ticket. Before work starts, write down its agent handoffs, pass criteria, and failure path. Then review where work waited, what evidence helped, and which decision needed a person. Expand the workflow after your team can follow each step and take ownership when a check fails.
Key takeaway
Define an owner, evidence requirements, pass criteria, and a next step for failure at every handoff.
Frequently asked questions
Which tickets should start in the pilot?
Choose one ticket your team considers low risk, well bounded, and suitable for delegated work. Keep the first run narrow, state the acceptance conditions, and name a human owner for review and QA before assigning it.
What should an agent include with a pull request?
Require a summary of the intended change, files changed, checks and outcomes, known limitations, assumptions, and unresolved decisions. Make sure the reviewer can match the pull request to the ticket and its acceptance conditions.
Should a human review every change?
Set checkpoints according to the decisions and permissions involved. Automate repeatable checks, and require a person where your policy calls for human judgment or approval. In repositories requiring approvals, GitHub’s Copilot review guidance requires someone other than the person who requested the Copilot pull request to approve it.
What happens when QA fails?
Record the failed condition and its evidence, assign an owner, and return the work for correction or human review. Rerun the checks that apply to the updated pull request. Stop retries when the agent cannot proceed or a person must make the next decision.

Andrii founded It’s a Plan and leads its product and roadmap, from the open-source edition to Pro for teams. He works with the project’s contributors and the teams that run It’s a Plan.
All posts by Andrii Poluosmak