How to Manage AI Agent Tickets: Criteria and Review

If the person who asked an AI agent for a pull request is also the one who approves it, that approval does not count: GitHub's own rules say so, and Atipol applies the same separation in its ticket flow. Every ticket also needs written acceptance criteria set before the agent starts, plus a logged, searchable decision history, so a delivery is checked against a target fixed in advance, not graded after the fact.
Agents deliver fast, but nobody can say what was approved
A CTO assigning work to AI agents usually gets a result quickly. The harder question comes after: what exactly was the agent asked to do, who checked the delivery against that request, and who signed off before it was merged or shipped. Without a ticket that records a target, a reviewer, and a decision, speed creates a trail that nobody can follow six weeks later when something breaks.
This is a process gap, not a model quality problem. A fast agent that works from an unwritten brief and gets waved through by the same person who asked for it produces output just as quickly as one that works from a clear ticket. The difference only shows up during an incident review, an audit, or a disagreement about what was actually promised.
That cost tends to surface at the worst possible time: during an incident postmortem, a security review, or a customer audit, when someone asks for the record of what an agent was asked to do and who approved it, and the honest answer is that no such record exists. NIST's AI Risk Management Framework (AI RMF 1.0, published 26 January 2023) frames this as a lifecycle concern rather than a one-off task: the framework is meant for voluntary use to help organizations incorporate trustworthiness considerations into the design, development, use, and evaluation of AI systems, not only into the output of a single agent run.
Write the acceptance criteria before the agent starts, not after
An acceptance criterion fixes, in writing, what a delivery must satisfy before the agent is launched. Setting the bar afterward, once the agent's own summary of its work is already on the table, invites grading the work against what was delivered rather than against what was asked. The rule here is plain: every ticket requires acceptance criteria written before the agent is launched, and a criterion the agent cannot meet should surface as a blocker before review, not during it.
A second element travels with the criteria: the file scope. Reserving which files or areas a ticket may touch before the agent starts means two tickets in progress cannot claim the same scope, so an overlap between two agents is caught at handoff instead of discovered inside a merge conflict.
In practice this means the criteria describe an outcome, not an implementation: which file or module the change applies to, what the diff must and must not touch, and the specific check that has to pass. A criterion the agent cannot satisfy is meant to surface as a blocker and go back to the requester before a reviewer ever opens the pull request, rather than being discovered during review once the work is already done.
The life cycle of a ticket assigned to an AI agent
GitHub's own documentation for its Copilot coding agent describes a concrete version of this life cycle. Once an issue is assigned to the agent, it acknowledges the assignment with a reaction, opens a dedicated branch and a draft pull request linked to the issue, and begins an agent session. While it works, it pushes commits and updates the pull request body with status messages. When it is done, it posts a finished-work event and requests a review, which is the signal that the ticket has moved from in-progress to awaiting a human decision.
The same documentation adds a troubleshooting detail that matters operationally: sessions time out after one hour, and a stuck agent is recovered by unassigning and reassigning the issue or reposting the triggering comment, not by waiting indefinitely.
GitHub's documentation describes several ways to put a ticket in front of the agent: assigning an issue from the Issues tab the same way you would assign it to a teammate, from GitHub Projects or GitHub Mobile, through the GraphQL API by checking that the coding agent appears as a suggested actor and then calling a mutation to assign it, or from the command line with the GitHub CLI. Whichever path is used, the agent only receives the issue's title, description, and the comments that existed at the time of assignment; comments added afterward are not seen by the agent, so later instructions have to go on the pull request itself, not back on the original issue.
Stages at a glance
The stages below generalize across tools that assign tickets to AI agents; the signal names differ by platform, but the sequence does not.
Naming the signal at each stage matters more than it looks: a team that only knows an agent is assigned, with no visible signal for acknowledgement, in-progress work, or completion, ends up polling the agent instead of being told when a ticket needs attention.
| Stage | Signal to watch | Who acts next |
|---|---|---|
| Assignment | Agent acknowledges the ticket | Agent starts work inside its reserved scope |
| In progress | Status updates and commits land on the ticket's branch | Team can comment to redirect before completion |
| Finished work | Agent posts a completion event | A reviewer other than the requester is asked to look |
| Review | Reviewer checks the diff against the acceptance criteria | Reviewer approves or sends it back with a blocker |
| Integration | Checks are rerun at merge time | Decision and ticket are recorded in the history |
The person who asked for the work should not be the one who approves it
GitHub's documentation on reviewing a pull request created by Copilot states that if a repository requires pull request approvals, the approval of the person who assigned the issue to the agent does not count toward that required number; another reviewer has to approve it before merge. The related training material is more direct about why: the developer who asked Copilot to create the pull request cannot approve it, which preserves the repository's required-review rule and keeps an independent check in the loop.
Atipol applies the same separation inside its own ticket flow: the project's agent lead reviews every delivery before integrating it, and that review is expected to cover the actual diff, not only the summary the agent gives of its own work. Integration then reruns the project's checks rather than relying solely on the review that preceded it, so a check that would have caught a problem is not skipped because a human already looked at the summary.
This is not a Copilot-specific carve-out. GitHub's general documentation on required reviews states plainly that pull request authors cannot approve their own pull requests, and that when a ruleset or branch protection rule requires reviews, an approval has to come from someone other than the author before the change can merge. The same page adds two details specific to Copilot: approvals by Copilot itself appear in that reviewers panel but do not count toward the required number, and the person who assigned the related issue to Copilot cannot approve the pull request it raised, which closes the loophole of approving indirectly through the agent.
The role separation from assignment to integration, as a diagram:
Turning ticket decisions into a history someone can search later
A reviewer's approval is only useful for as long as someone remembers it happened. Atipol keeps the history of every ticket and the review decisions that validated it, producing a record of who requested what and who approved what before an action was integrated. Each call an agent makes is linked to an agent, a ticket, and a result, together with any approval granted or denied, which turns a question raised weeks later into something a reviewer can search rather than something a reviewer has to remember.
A log set up after an incident does not help establish what was actually read or written during it; the record has to exist before the agent is connected, not after something goes wrong.
The reasoning for building that log before connecting an agent, rather than adding it after a problem surfaces, is the same one behind writing acceptance criteria before launch: a record assembled after the fact can describe what probably happened, but it cannot replace a line that ties a specific call to the agent that made it, the ticket it was working on, and the approval that was granted or denied at the time.
When a platform's native flow is still the right choice
Teams whose AI agent work happens entirely inside one GitHub repository, with a single coding agent and a branch-protection rule already in place, get the assignment, draft pull request, finished-work event, and independent-approval rule directly from GitHub, as described above, without adding another system. That native flow is enough when the acceptance criteria live in the issue description and one platform's review rules are the only ones that matter.
The gap appears once a team runs more than one agent, or more than one tool, against a shared backlog: file scope has to be reserved across tools, acceptance criteria have to be visible to whichever agent picks up the ticket next, and the decision history has to cover agents that never touch GitHub's pull request flow at all. That coordination across tools and agents is what a ticket system built for AI agents, such as Atipol's, is meant to cover; see how several agents share tickets and file scope without colliding at atipol.ai/agentic-ai-blog/parallel-claude-code-agents.
The same GitHub documentation lists the limits of that native flow on its own terms: the agent is not available on Enterprise Managed User personal repositories, so those have to move to an organization-owned repository with GitHub-hosted runners; a session that appears stuck can usually be recovered by unassigning and reassigning the issue rather than waiting it out, since sessions time out after one hour; and pull requests from the agent stay in draft and do not trigger GitHub Actions automatically, so a human still has to approve and run the workflow by hand. None of that changes once a second agent or a second tool joins the same backlog; it just means the native flow was never meant to coordinate more than one.
Building the practice into a team
None of this requires new tooling to start: a ticket with written acceptance criteria, a reviewer who did not request the work, and a record of the decision cover most of the gap described above. The governance framework behind that practice, including a sample usage policy and where human review has to sit before a merge, is laid out at atipol.ai/agentic-ai-blog/ai-agent-governance.
A minimal version of this practice fits on one ticket: a written acceptance criterion, a named reviewer who was not the requester, and one line in a log recording the decision. Everything else described above, branch protection rules, API-driven assignment, a dedicated audit trail, is a way of enforcing that minimal version at a larger scale once more than one agent and more than one reviewer are involved.
To see this ticket, review, and history flow applied end to end across a team of agents, the guided tour at atipol.ai/tour walks through assigning a ticket to an agent lead, setting acceptance criteria, and reviewing a delivery before it is integrated.
Written acceptance criteria set before the agent starts, a reviewer who did not request the work, and a logged decision that exists before the agent is connected.
Frequently asked questions
Who should write the acceptance criteria for an AI agent ticket?
Whoever requests the work writes the criteria before the agent is launched, since the goal is a target the agent can be checked against, not a summary graded after delivery.
Can the agent that completed a ticket approve its own pull request?
No. Per GitHub's documentation on Copilot coding agent and on required reviews generally, an approval from the person who assigned the issue does not count toward a repository's required reviews, and a different reviewer has to approve the change before merge.
What should an audit log for AI agent tickets record?
Each entry should link an agent, a ticket, and a result, along with any approval granted or denied, and it needs to exist before the agent is connected so it can answer questions raised after the fact.
Sources
- Microsoft Learn, Assigning, tracking, and troubleshooting Copilot in the cloud, mise à jour 27/10/2026
- GitHub Docs, Reviewing a pull request created by Copilot, consultée le 11/11/2026
- GitHub Docs, Approving a pull request with required reviews, consultée le 11/11/2026
- NIST, AI Risk Management Framework (AI RMF 1.0), publié le 26/01/2023
The public demo shows a fictional organization at work, no account needed. The free plan includes a project, three agents and an agent lead.
