Agentic AI workflows in production: how software actually gets built with agents

What "agentic" actually means

A chatbot answers. An agent acts: it plans, uses tools — reads files, writes code, runs tests, calls APIs — observes what happened, and adjusts. An agentic workflow is a system of such agents with defined roles, shared state, and checkpoints, pointed at a goal bigger than any single prompt: ship this feature, migrate this codebase, translate this product into four languages.

The hype version stops there. The production version lives or dies on structure — because an agent with no structure is a very fast intern with no supervisor.

The pipeline we actually run

Five stages, and every one earns its place:

• Groom. Before anything is planned, research agents sweep the territory — the codebase, the documentation, the edge cases, the states nobody remembers. Exhaustively. Most failed AI projects die here, by skipping here.
• Plan. A planning agent turns the groomed picture into a phased PLAN.md — and, crucially, a list of questions for the human owner. An agent that guesses at ambiguity ships the wrong thing fast; an agent forced to surface its questions ships the right thing fast.
• Build. Implementer agents execute the plan phase by phase — and where phases are independent, they run in parallel. When we localized our own site into four languages, four agents produced four native-quality translations simultaneously; the wall-clock cost of "one more language" was almost zero.
• Verify. The agent that built something never gets to approve it. Separate QA agents check the work against the plan, and a senior engineer reviews every line before it ships. Anything that fails goes back to build — that red loop in the diagram runs as many times as it needs to.
• Ship. Staging link from week one, demo every Friday, client owns everything.

The five patterns that survive contact with production

1. The tracker file

The single most boring and most important piece: a plain markdown file on disk that every agent reads before acting and writes after. It's the workflow's memory and its audit log. Sessions crash, contexts fill up, humans go to sleep — the tracker file survives all of it, and any agent (or human) can pick up exactly where the last one stopped.

2. Phases with gates

Agents are excellent sprinters and terrible marathon runners. Cutting work into phases with explicit completion criteria — each gated on the last — keeps every agent working on a problem small enough to hold in its head, and gives humans natural inspection points.

3. Fan-out, fan-in

Independent work runs in parallel: one agent per module, per language, per test suite. The fan-in matters as much as the fan-out — outputs get re-verified together, because four individually-correct pieces can still disagree with each other.

4. The grill list

Every planning stage must produce questions for the human, and "no questions" is treated as a red flag, not a green one. Ambiguity that isn't surfaced becomes a confident wrong decision at machine speed.

5. Verifier separation

Builders never grade their own homework. Separate verification agents — plus a human reviewer with taste and context — are what turn "the demo works" into "this is production software."

What agents are still bad at

Honesty is part of the pitch: agents don't have taste, they don't know when they're wrong, and they will confidently optimize the wrong goal if the goal is stated loosely. That's precisely why the workflow above has two human diamonds in it and a senior engineer's name on every release. Agentic AI doesn't remove the expert — it removes everything that used to waste the expert's time.

Why this matters to you

The economics are not subtle. A workflow like this lets one senior engineer deliver what used to take a team — which is how a studio can quote a fixed price, show a working demo every Friday, and ship an MVP in weeks. The agents produce the volume; the structure produces the reliability; the human produces the judgment.