Agentic Workflows for Software Delivery: A Practical Map
By Sebastiaan Jansen · · 9 min read
An agentic workflow is a delivery loop where a coding agent plans and edits code from a shared ticket, the git repository and the team's rules, and a person reviews the result before it ships. The agent doesn't replace the backlog, the pull request or the release decision. It shortens the path from a named piece of work to a diff someone can accept or send back.
It pays off when Slack threads, call notes and error alerts already describe the work, and the slow part is turning that description into a plan, a branch and a reviewable change. Put the input on a ticket, give the agent a bounded job, and keep version-checked writes and human review between the agent and main.
What the loop actually changes
A trigger creates or updates a ticket. A planner reads the ticket, the relevant code and the team's constraints. An executor changes files on a branch. A reviewer accepts, edits or rejects the change, and the ticket moves only when that check passes.
"Agentic" means the software can pick its next tool call inside a boundary you set: open a file, search the repo, draft a plan, then edit. The agent still doesn't own priority, scope or production.
A chatbot stops once it has answered. A script can't judge a ticket. An editor assistant is invisible to the rest of the team. This loop gives you a shared ticket, an agent that can act, and gates a teammate can audit. AI project management covers planning and standups; this article sticks to the path from ticket to merged change.
Where an agentic workflow sits in the week
Your week already has a shape: intake, triage, a cycle, build, review, release. The agent belongs in build and review, and it shouldn't invent a second backlog.
- Intake stays human. A Slack message, a call note or a Sentry issue becomes a ticket with a type and a stage.
- Triage sets priority, owner and "not now." The agent may draft a suggestion, but a person confirms it.
- Planning reads the repo. The agent proposes steps, and the owner edits the plan before any write.
- Implementation happens on a branch, with the checks the repo already runs.
- Review stays a human decision when the change touches behaviour, security or a public API.
- Release and rollback stay on the path you already trust.
Unfinished work rolls into the next cycle only after someone has looked at the rollover. If agents close work no reviewer has seen, a roadmap counted from tickets will lie to you.
The stages of an ai agent workflow
An ai agent workflow is the same loop, described from the agent's side. Five stages are enough. Add another only when there's a real handoff.
1. Trigger
Something observable starts the job: a ticket enters a ready stage, a comment asks for an agent, or a scheduled pass reads a labelled queue. Don't let an agent watch all of Slack, because most messages aren't work. Write the entry rule on the ticket type in one line.
2. Context pack
Give the agent only what this job needs: ticket title, acceptance notes and links; the repository, default branch and paths in play; branch names, test commands and files it must not touch; and the commit the plan was written against.
That last item is why version-checked writes matter. If main moves while the agent is planning, the write should fail or rebase in the open instead of landing on a stale tree.
3. Plan
The agent returns the files it expects to change, the tests it expects to run, and the risks it can't judge. The owner accepts that note or rewrites a few lines. For a small bug, six to twelve lines is plenty. Larger work should already be split into tickets a person can review one at a time.
4. Execute
The agent edits, runs the checks you named, and opens a pull request that links the ticket and lists what it didn't verify. GitHub's pull request model is still the right container: a branch, a diff, a conversation, a merge.
5. Review and record
A person reviews. Comments go back either as the next agent job or as human edits, and the ticket says which. On merge, the ticket moves to done with the pull request link. Cycle time runs from the ready stage to merge, not from the first pasted log.
DORA's four metrics are still the scoreboard: deployment frequency, lead time for changes, change fail rate, and time to restore. If deploy frequency goes up and the change fail rate goes up with it, you haven't gained anything.
Who does which job
| Job | Person | Agent |
|---|---|---|
| Set priority and cycle scope | Yes | Can draft a suggestion |
| Write acceptance notes | Yes | Can propose a checklist |
| Draft a plan from the repo | Reviews it | Yes |
| Edit code on a branch | When the plan is wrong or the risk is high | Yes, inside the files the plan named |
| Approve the merge | Yes | No |
| Update the roadmap | The board counts ticket stages | No separate status |
Every ticket in the agent column needs a human owner, the same way every pull request needs a reviewer. AI coding agents covers how teams keep that control once more than one agent can open work.
A worked example
This is an illustration, not a measured rollout, and the names are made up.
Tuesday, 09:40. Support pastes a report: the filtered CSV export drops rows. The on-call opens a bug, stage Triaged, owner Priya. Acceptance notes: an export with an active filter returns the same rows as the on-screen table; add a test; don't change the public export URL.
10:05. Priya marks the ticket ready, and that stage change is the trigger. She doesn't paste the repo into chat.
10:12. The agent plans against commit a1b2c3. The export query ignores the filter object the table already uses, so the plan is to change export.ts to call the same helper as the list view, add a test with two rows and one active filter, and leave the column picker and permissions alone. Priya strikes a line that proposed a new helper and replies: use the existing one, then start.
10:28. A pull request links the ticket, names the commit the plan used, and says only the export tests were run. CI runs the rest.
11:00. Priya asks for the empty-filter case to stay on the old path, and that comment becomes the next job. She merges the update at 11:20 and the ticket moves to done. In this story, ready to merge took about 75 minutes. That figure belongs to this example only; the number worth watching is a percentile over many tickets.
Four things kept it reviewable: a small scope, a named owner, a plan accepted before any write, and a pull request that admitted what it hadn't tested. Tacking "also clean up exports" onto the same branch would have wrecked the review.
Client calls work the same way. Meeting notes become a reviewed ticket first, and only the accepted lines turn into agent work.
Guardrails worth writing down
One writer per ticket. With two agents on one branch, nobody knows which plan is current.
Allowed paths. A billing fix has no reason to touch the marketing site.
No silent dependency bumps. A lockfile change gets its own ticket unless the owner asked for it.
Tests CI already runs. A green line from a test CI doesn't run is a claim, not a check.
Secrets stay out of the prompt. The agent needs the repo and the ticket. It doesn't need production credentials.
The agent can't mark its own ticket done. "In review" means a person is assigned. Rollback stays with the on-call: the agent may draft a revert, and the on-call decides.
MCP, the Model Context Protocol, is one way to hand the agent those tools without pasting the repo into chat. What an MCP server is explains it in plain terms. The risk lies in how many write-capable tools you turn on and who is allowed to call them.
Claude Code, Codex, and the ticket in the middle
Claude Code and Codex can both plan from a repository and open a change, but neither is a system of record. Tickets, stages, cycle scope and the roadmap need a home the whole team can see after the session ends. Use the session for the plan and the diff, use the tracker for priority, owner and stage, and link the two. Claude Code for teams covers shared context, and OpenAI Codex for software teams covers setup and guardrails.
Falrow is one workspace built around that split. Slack messages, call notes and Sentry errors become tickets, and Claude Code and Codex plan from the git repository under the team's rules, with version-checked writes. You can also start on Linear, Jira or GitHub Issues with Copilot, Cursor, Claude Code or Codex as the executor; a tracker, a repo and a written ready-rule are all you need. The loop breaks down when the tracker and the executor disagree.
The agents feature is the MCP server those tools call, and the MCP tool catalogue lists what they can see. Falrow is in private beta, with access and pricing on request.
How to start this month
- Pick one ticket type. Small bugs are a good place to start.
- Add one stage, ready for an agent, with a written entry rule.
- Choose one repository and one agent.
- Require a plan comment before any write for the first 15 tickets.
- Review every pull request yourself, then decide whether a second person can share the queue.
Stop if the agent keeps planning against the wrong files, if review comments keep pointing at the same missing rule, or if lead time and change fail rate both get worse. Fix the rules or narrow the ticket type before you add another agent.
Track the queue where you already track operations: who owns it, what "stuck" means, and when a ticket goes back to a person. If you forecast, treat the forecast as a spread drawn from your own history, not a date you promise.
What this is not
Don't merge to main because a model said the tests passed, unless you already auto-merge that class of change when a human opens it.
Don't drop acceptance notes. "Make exports better" produces a wide diff. "Filtered CSV matches the table, with a test" produces one you can review.
Don't keep a second roadmap. Work that never entered the cycle won't show up when you count tickets. Write the ticket first, even if it takes two minutes.
FAQ
What is an agentic workflow in software delivery?
It's a repeatable path from a ticket to a reviewed change, where a coding agent may plan and edit inside rules the team has written down. A person still owns priority, scope and the merge. The agent works on a branch against a named commit and reports what it didn't check.
How is this different from CI?
CI runs the checks you defined, the same way every time, after the code exists. The agent decides which files to read and which edit to try, then uses CI as a gate. CI is good for tests, lint and builds, and bad at choosing scope. Keep both.
Do we need an MCP server to run this?
No. Pasting context and copying a diff back works for one developer, but it falls apart once several people need the same rules. An MCP server lets tools such as Claude Code and Codex call the tracker and the repo without a fresh paste each time. To start, a written stage and a pull request are enough.
What should we measure first?
Measure lead time from the ready stage to the merged pull request, and count how often those changes fail after release. One fast ticket isn't a trend. Over a few weeks, compare a percentile against similar tickets that never entered the agent column, and collect that history before you change the process again.