Agentic Workflows in Everyday Engineering Practice

Agentic AI has moved past the demo stage. Developers aren't just asking a model to finish a line of code anymore. They're handing over whole tasks, walking away, and coming back to a pull request. Forrester's State Of Agentic Software Development, 2026 report calls this shift the rise of "TuringBots," AI systems that now touch nearly every stage of the software development lifecycle, not just the coding part.

The path here has a shape worth naming. In 2023 and 2024, AI mostly wrote code and unit tests. In 2025, it crept into the tasks next door: documentation, design help, test generation. By 2026, agents work across analysis, planning, design, build, test, and delivery, and increasingly they're stitched together so one agent hands off to the next.

Forrester's most useful finding might be the warning buried in the data. Firms that apply AI narrowly, mostly to coding, see that coding speed up by 20 to 40%. But overall team output rises less than 10%. The bottleneck doesn't disappear. It just moves. Code gets written faster, then it piles up in review, or testing, or deployment, waiting for a human to catch up.

These practices have moved well beyond a fringe experiment. Depending on the survey, somewhere between 76 and 85% of developers now use AI coding tools, and half use them every day. This is already the normal condition of writing software, not an edge case. The developers actually getting value out of it are the ones treating agents like collaborators across the whole workday, not just a faster typing tool.

What an agent actually does when you hand it a task

A code assistant reacts. You type, it suggests, you accept or you don't. An agent works differently: it plans, acts, checks its own work, and tries again if something's off.

Take a real example: "add rate limiting to our API gateway." Handed to an agent, here's roughly what happens:

• It reads through the codebase and figures out which files matter.
• It builds a plan: which files to touch, what tests to write, what dependencies need updating.
• Some agents stop here and show that plan to a human before doing anything else.
• Once approved (or if no approval step exists), it makes the changes across however many files are involved, writes tests, runs them, and opens a pull request.

Anthropic's Claude Code is a clear example of what this looks like in practice. It reads the whole codebase, works inside the terminal, inside VS Code, and inside Slack. It supports reusable "Routines" for CI pipelines, a "Remote Control" feature for picking a session back up on a different device, and a CLAUDE.md file where a team writes down its coding standards once instead of repeating them in every prompt. It can also spin up parallel subagents to work on more than one piece at a time.

Cognition's Devin takes a plain-English spec and goes further: designing the architecture, writing the components, testing them, and debugging when something breaks. Google's Jules and OpenAI's Codex sit in similar territory.

Multiagent setups add another wrinkle. Instead of one agent doing everything in sequence, a lead agent can hand off smaller pieces to specialized subagents, so several threads of work run at once instead of one after another.

This isn't aimed at impressing anyone with what the tool can do. It matters because knowing what happens inside that process is what makes the oversight habits in the next section make sense, instead of feeling like paperwork for its own sake.

How the SDLC roles shift when agents do more of the execution

Forrester's research points to something bigger than a productivity bump: the roles themselves are changing shape.

• Product managers now build working prototypes themselves and write specs directly, feeding spec-driven development instead of just describing requirements to someone else.
• Developers write less code by hand and spend more time reviewing, steering, and coordinating what agents produce. As trust builds, some review only a fraction of the output, if any.
• Testers move from writing test scripts to setting quality targets and watching over testing agents that do the scripting.
• Architects and senior engineers spend more time on system design, setting boundaries, and what's called context engineering, making sure agents operate inside the right guardrails.

The skill that matters across every one of these roles is judgment. It's the ability to state intent, context, and limits clearly enough that an AI collaborator can act on them correctly the first time.

PepsiCo's use of agents for software testing, reported by Fortune in 2025, offers a concrete case: the agents didn't just speed up validation, they caught technical gaps that human testers working alone had missed.

This is where the idea of "human on the loop" replaces "human in the loop." Instead of approving every single step an agent takes, someone reviews the decisions after the fact. That's a meaningfully lower bar of trust required to get real use out of these tools today. And when an agent gets stuck, the answer is to diagnose and adjust it. It's escalation: a human steps in, unblocks it, and the work continues.

The developers adapting fastest to this shift aren't the ones cranking out the most code by hand. They're the ones who've gotten good at writing intent instead of instructions, at describing the outcome they want rather than the steps to get there.

Where agents fit into the actual rhythm of a development day

Developers using AI coding tools save roughly 3.6 hours a week, on average. What matters more is what that time gets redirected toward.

Mornings increasingly start with delegation, as a developer assigns an overnight or background task, a bug investigation, a full test suite run, or a documentation pass, and lets the agent work while attention goes elsewhere. Claude 4.5 Sonnet's ability to run autonomously for up to 30 hours gives a concrete sense of what "working in the background" can now mean at the frontier of what's available.

Parallel workflows are becoming common too: multiple subagents assigned to different pieces of work running at the same time, not one handoff after another.

The tools reflect this. GitHub's Copilot Workspace, in its 2026 form, takes a GitHub Issue or a plain-language prompt and turns it into a structured plan and a pull request. It doesn't yet manage two-way communication with CI/CD pipelines, so agents are handling code generation here, not release decisions. GitLab's Duo Agent Platform goes further into the workflow itself, automating merge request creation, code review, and CI/CD task management, right inside the tools developers already use daily.

Capital One's experience with its Chat Concierge tool, also reported by Fortune in 2025, is a useful reminder that shipping isn't the finish line. Using a proprietary multi-agent workflow, the team cut latency by a factor of five after launch. The real work happened in the iteration that came after.

The habit underneath all of this: treat what an agent produces as a first draft that needs real review, not a finished answer that just needs a rubber stamp.

The oversight habits that make autonomous workflows reliable rather than risky

Start with the uncomfortable number: somewhere between 40 and 62% of AI-generated code contains a security vulnerability of some kind. And 83% of companies planning to deploy AI agents found out, often the hard way, that their existing security tools were built to watch code that neither writes nor runs itself.

Multiagent systems add a specific risk: a mistake or a hallucinated detail from one agent can pass to the next agent in the chain faster than a human reviewer can catch it. That means review timing isn't a detail to figure out later. It has to be designed in from the start.

Apiiro's 2025 research found that enterprises are seeing more than 10,000 new security findings a month tied directly to AI-generated code. At that scale, manual review alone simply can't keep up.

A few practical habits are showing up in teams that handle this well:

• Plan review before execution. The agent shows its plan, a human signs off, then the work begins.
• Scope limits. Boundaries set by file, module, or branch, so an agent can't wander outside its lane.
• Rules files like CLAUDE.md. Coding standards written down once so the agent works within them automatically, instead of needing to be told every time.
• Escalation protocols. Clear rules for when an agent should stop and ask, rather than guess and move on.

Forrester's position is direct. Guardrails, the ability to audit what happened, and clear ownership of decisions all need to be in place before expanding how much autonomy agents get in production systems. Deloitte's 2025 research backs this up with a number worth sitting with: only 11% of organizations are actually running agentic systems in production, while 30% are still exploring. That gap concerns something other than whether the technology works. It's about whether the governance around it is ready.

Oversight is a driver of speed here. It's what keeps the speed from collapsing later, once code churn and rework start eating the gains, which is exactly the problem in the next section.

Why the velocity gains don't automatically become quality gains, and what closes the gap

A developer using AI can produce three to five times more lines of code in a session. That sounds like a clean win, until the quality data shows up.

GitClear's research tracked code churn, meaning code that gets rewritten or reverted shortly after being written, rising from a 3.3% baseline in 2021 to somewhere between 5.7 and 7.1% in 2024 and 2025. More code, produced faster, is not the same thing as more value delivered faster. Pull requests that are co-authored with AI show roughly 1.7 times more issues during review. And AI-authored code now makes up about 22% of what gets merged, out of a global total where AI-generated code accounts for 41 to 46% of all commits, up from 26% in an earlier baseline period. Authorship burden is dropping, but review burden is climbing right alongside it.

The gap closes when testing gets treated as seriously as code generation, not bolted on afterward. Qodo's 2025 AI Code Quality report found that using AI in the code review step itself raised quality improvements to 81%, compared to 55% without it. Atlassian's 2026 study of its RovoDev tool found that nearly 39% of the comments it left during code review led to actual changes in the next commit, agents reviewing agent-written code, working as a daily habit rather than a lab experiment.

The same logic applies to review standards: AI-written code calls for at least the same rigor as human-written code. PepsiCo's testing agents, again, are the clearest example: they found gaps humans working alone missed. Quality, in that case, wasn't a risk being managed. It was a direct benefit of running agents on the review side too.

The pattern underneath all of it: gains compound when testing is agentic. The teams pulling ahead are running agents on both sides of the pull request, the one that writes it and the one that checks it.

Choosing the right model for each task rather than committing to a single one

The idea of a single "best" model doesn't hold up well under its own data. Stanford's AI Index in 2025 tracked a jump on the SWE-bench coding benchmark from a 4.4% solve rate to 71.7%, a 67.3 percentage point improvement, in one year. Whatever's "best" changes on a timeline closer to a quarter than a year.

A snapshot from mid-2026 makes the point: Leading frontier models compete closely on SWE-bench Verified and related production-grade agentic coding benchmarks, with the top positions shifting each quarter. Different models lead on different benchmarks, meaning the stronger pick for scripting and terminal-based automation may differ from the leader on code-generation tasks. Several other frontier models cluster closely behind, separated by only a few percentage points on SWE-bench Verified. For teams that need an open-weight option, for private or air-gapped setups, capable open-weight models have reached competitive scores on SWE-bench.

Here's the twist worth sitting with: the gap between the best and the worst frontier models on real-world coding tasks is under 8%. Which model is "best" depends far more on the specific job than on where it sits on a leaderboard. And older benchmarks like HumanEval are largely maxed out at this point. SWE-bench Pro, Terminal-Bench, and Toolathlon are better stand-ins for what production agent work actually looks like now.

A practical pattern is emerging around this: route the task to the tier of model that fits it.

• Frontier models (Claude Opus, GPT-5) for hard reasoning and architecture calls.
• Mid-tier models (Claude Sonnet, smaller GPT variants) for high-volume, everyday coding tasks, at a fraction of the cost.
• Open-weight models (Llama, Qwen) where data has to stay private or air-gapped.

The real decision concerns which model wins this quarter. It's whether there's infrastructure in place to route the right model to the right task automatically. Teams that build routing across multiple providers tend to beat teams locked into one vendor, on both quality and cost. Tools like Claude Code already support flexible access across model providers, which makes the IDE itself a natural place to build this routing without adding a whole new layer to the stack.

What agentic tooling actually costs and how to evaluate whether it is paying off

The price tag isn't small anymore. Teams using agentic tools are spending somewhere between $200 and $2,000 or more per engineer per month in token costs, on top of whatever seat licenses already cost.

The return, where it's been measured, looks solid on paper. Fullview's 2025 AI Statistics report put the average return at $3.70 for every dollar spent on AI investment, with top performers hitting $10.30. Microsoft's own market study from early 2025 found an average return of 3.5 times investment, with the top 5% of companies reporting returns as high as 8 times.

But that return doesn't show up automatically. GitHub's own research found developers save 30 to 60% of their time on coding, test generation, and documentation. That only turns into a company-wide delivery gain if code review, CI/CD, and QA can move at the same new pace. Otherwise the saved time just sits in a queue somewhere downstream, which is exactly the bottleneck Forrester flagged at the start: faster drafts don't mean faster delivery unless everything after the draft speeds up too.

What does measuring this well actually look like?

• Watching code churn alongside output volume, since raw lines of code without it is a misleading number.
• Tracking security findings per month, using Apiiro's 10,000-plus figure as a rough baseline for what unmonitored AI output looks like at enterprise scale.
• Capital One's approach with Chat Concierge: watching latency from day one and tuning its multi-agent workflow specifically around that metric, treating measurement as an ongoing job, not a one-time check after launch.

Gartner expects 40% of enterprise applications to have AI agents built in by the end of 2026. Once that many companies are doing it, having agents at all stops being the edge. How well a team measures and tunes what those agents are doing becomes the actual difference.

The habits and infrastructure that separate teams already compounding gains from those still experimenting

The line between teams pulling ahead and teams still poking at this technology isn't the tools they've bought. Most of these tools are available to everyone. What's built around them makes the difference.

Teams compounding gains tend to share a few things: agentic use spread across the whole SDLC instead of parked at the coding step, oversight habits (plan review, scope limits, escalation paths) built in from the start rather than added after an incident, model routing set up so the right tool handles the right task instead of one model handling everything, and measurement that tracks churn and security findings alongside speed, not speed alone.

Teams still experimenting tend to look almost identical from the outside. Same tools, same headline numbers about lines of code generated per day. What's missing is usually the boring part. The rules file, the routing logic, the review cadence, and the person whose job it is to watch the churn number every month.

Forrester's warning from the start of all this holds up: apply AI at one point in the pipeline, and the bottleneck just moves somewhere else. Apply it across the whole rhythm of the work, planning, building, testing, reviewing, with the right oversight at each step, and the gains actually stack instead of just shifting where the wait happens.