A first pass on every pull request
An agent reviews diffs against your standards — bugs, security, style, missing tests — and leaves structured comments before a human ever looks.
A first pass on every pull request, in brief
| The job | An agent reviews diffs against your standards — bugs, security, style, missing tests — and leaves structured comments before a human ever looks. |
|---|---|
| Tools it needs | GitHub, Jira, Linear, Slack, Sentry |
| Setup | 4 steps, about ten minutes |
| Runs when | Something happens in Slack |
| Approval | Yours, per category — nothing is sent on your behalf unless you say so |
| Where it runs | Your own machine. Credentials stay in a local vault. |
What the agent actually does
Reviewers start from an annotated diff
The agent reviews against your written conventions, not a generic style guide — the error-handling pattern your codebase uses, the naming rules, the architectural boundaries you care about. Standards nobody had time to enforce consistently get enforced on every diff.
Security and edge cases first
Unvalidated input, injection paths, unhandled failure modes, race conditions, resources that are never released. It reads for the failure classes that survive human review precisely because they require reading carefully at the end of a long day.
Humans review the review
Comments land on the PR as suggestions, not verdicts. Nothing merges on an agent’s say-so. The value is that the reviewer starts from a diff whose obvious problems are already annotated.
The tools this job needs
GitHub
Where the work arrives. Where the code — and half the process — lives. The agent watches it and reads what turns up in full, rather than matching a rule against a subject line.
Jira
Context the agent pulls in before deciding. The ticket system of record for engineering work. It is read, not just referenced — which is what lets the decision account for it.
Linear
Context the agent pulls in before deciding. Fast issue tracking that deserves fast automation. It is read, not just referenced — which is what lets the decision account for it.
Slack
Where the result lands. Team chat where operations actually surface. Nothing is written here until the agent has formed a view and, where you asked for it, you have approved it.
Get this agent
First-Pass Reviewer
An agent reviews diffs against your standards — bugs, security, style, missing tests — and leaves structured comments before a human ever looks.
Runs on your own machine. Asks for GitHub, Slack and nothing else — you approve the connection, and the agent inherits whichever AI model you already use.
You can see exactly what it did
What first-pass review is actually for
The purpose is not to replace the reviewer — it is to make sure the reviewer’s attention is spent on design rather than on catching a missing null check for the fortieth time. When mechanical issues are already flagged, human review shifts to the questions only a human can answer: is this the right abstraction, does it fit where we are going, is the complexity justified.
Why it catches what tired reviewers miss
Review quality degrades with diff size and with the time of day, and everybody knows it. An agent reads the four-hundredth line as carefully as the first and never assumes a section is fine because it looks familiar. That is a genuine complement to human review rather than a cheap substitute for it.
Reviewing the review
An agent reviewer that comments on everything gets muted within a week. The useful configuration is narrow and confident: flag correctness and security issues, flag violations of standards you actually wrote down, and stay quiet about taste. Tuning that threshold against real PRs in the first fortnight is what determines whether the team keeps it.
Build it in AGNT
- Connect GitHub with one sign-in and choose which repositories are in scope.
- Give the agent your conventions — a contributing guide, a style document, or a skill you write for it.
- Start in comment-only mode on a single repository so the team can judge signal against noise.
- Tune what it comments on, then expand to the repositories where it proved useful.
The definition, ready to paste
Here is the shape in full rather than in prose: a trigger, a decision, an action. Paste the definition below into a new workflow and it loads exactly as drawn.
{
"id": "d464c551-32f3-4f9f-a77b-b02a03e4a04e",
"name": "A first pass on every pull request",
"nodes": [
{
"id": "2aa34ed6-2081-4662-ac33-b400b29bfafc",
"text": "Watch Slack",
"x": 512,
"y": 144,
"isEditing": false,
"type": "receive-slack-message",
"icon": "connect",
"category": "trigger",
"isSelected": false,
"parameters": {},
"description": "Listen for incoming Slack messages in a specified channel and trigger the workflow when a new message is received.",
"error": null,
"isActive": false,
"output": null,
"outputs": {}
},
{
"id": "84e19391-da54-49f5-a364-7af25bb9cc3a",
"text": "Read it and decide",
"x": 512,
"y": 336,
"isEditing": false,
"type": "agnt-agent",
"icon": "connect",
"category": "action",
"isSelected": false,
"parameters": {
"instructions": "The agent reviews against your written conventions, not a generic style guide — the error-handling pattern your codebase uses, the naming rules, the architectural boundaries you care about. Standards nobody had time to enforce consistently get enforced on every diff."
},
"description": "An agent reviews diffs against your standards — bugs, security, style, missing tests — and leaves structured comments before a human ever looks.",
"error": null,
"isActive": false,
"output": null,
"outputs": {}
},
{
"id": "f785598e-745b-42a9-aa68-56e5f1fc6962",
"text": "Act in GitHub",
"x": 512,
"y": 528,
"isEditing": false,
"type": "github-api",
"icon": "connect",
"category": "action",
"isSelected": false,
"parameters": {
"action": "GET_AUTHENTICATED_USER"
},
"description": "Interact with GitHub: repos, branches, files, issues, comments, pull requests, reviews, releases, Actions/CI, and search.",
"error": null,
"isActive": false,
"output": null,
"outputs": {}
}
],
"edges": [
{
"id": "41867f5e-db34-420a-a314-6d8c2d4e5a78",
"start": {
"id": "2aa34ed6-2081-4662-ac33-b400b29bfafc",
"type": "output"
},
"end": {
"id": "84e19391-da54-49f5-a364-7af25bb9cc3a",
"type": "input"
},
"startX": 800,
"startY": 168,
"endX": 512,
"endY": 360
},
{
"id": "d32d4a72-aa94-4e30-a775-bea650e6d260",
"start": {
"id": "84e19391-da54-49f5-a364-7af25bb9cc3a",
"type": "output"
},
"end": {
"id": "f785598e-745b-42a9-aa68-56e5f1fc6962",
"type": "input"
},
"startX": 800,
"startY": 360,
"endX": 512,
"endY": 552
}
],
"zoomLevel": 1,
"canvasOffsetX": 0,
"canvasOffsetY": 0,
"isTinyNodeMode": false
}Put this agent to work
Free, local, and it asks for GitHub, Jira, Linear, Slack, Sentry and nothing else.
Common questions
Can it approve or merge pull requests?
Not unless you deliberately grant that, and most teams never do. The default is that it comments and a human decides.
Does our code get sent to a model provider?
Only to the provider you choose. Point AGNT at a local model through Ollama and review happens entirely on your own hardware — which is the usual answer for private codebases.
How is this different from a linter?
A linter checks rules expressible as patterns. An agent reads intent, so it can notice that a function no longer does what its name and callers assume — which is not a pattern anybody can write.