It is a division of labor. The industry sells one model that reads a request, reasons, calls a tool, checks its own work and writes the answer in a single unbroken breath. The picture is seductive and it does not survive production, because a system that does everything at once can be held accountable for nothing.
On the name. PEVG is planner, executor, verifier, generator. If you have seen it expanded any other way, that expansion is not this framework.
Consider what failure looks like in the unified version. An analyst asks the system to investigate a transaction that tripped a fraud signal, and it returns a confident summary naming the wrong counterparty. Where did the error enter? Did the reasoning misframe the task? Did a tool return stale data? Did the check pass something it should have caught? Did the prose overstate a tentative finding?
In a unified agent there is no way to know, because the four acts were never distinguished. A failure that cannot be located cannot be fixed. Agent systems do not usually fail because the model reasoned poorly. They fail because no module owned the failure, so no module could be taught.
Each module carries a contract, which is to say a declared shape of input and output the rest of the system can depend on. The contract is what turns a role from a vague intention into a governable component. Where others see a multi-agent system, this pattern sees a single accountability problem split until every piece can be named.
What steps does this task require, and in what order?
The planner reads a task and produces an ordered set of steps, each naming what it needs and what it will yield, with the dependencies made explicit. Planning is not thinking ahead. It is naming the steps a system can be held to.
A plan written down can be inspected before a single tool fires, reviewed by a human when the stakes demand it, and compared afterwards against what the steps actually produced. An agent that plans silently inside its own reasoning offers none of that: its intentions are invisible until they have already become actions, and an action you cannot preview is an action you cannot govern.
This is the module where intelligence concentrates and therefore where investment pays most. A good decomposition gives the executor clean steps and the verifier checkable claims. A poor one sends the whole workflow chasing the wrong evidence with perfect tool discipline.
Which tool serves this step, and what may it touch?
The executor turns a step into a tool call. It is the module closest to the real world and therefore the module most tightly bound. For every step the planner names, it knows which tools may serve it, what inputs they accept, and above all what they are permitted to touch.
Least privilege is the rule: the executor receives the narrowest access a step can succeed with, never the broadest the agent could use. An executor that cannot exceed its grant cannot be talked into exceeding it by a cleverly worded prompt. A workflow that drafts a customer letter has no business holding the authority to move money.
The executor decides nothing. It does not judge whether a step is wise or whether a result is true. It acts on the plan and hands what it gets to the verifier, and that narrowness is the point.
Does this result hold, and may it be believed?
The verifier checks a result before the result is trusted. It is the conscience of the pattern and the module a regulated institution cannot operate without. Verification is not quality control. It is the moment an agent earns the right to be believed.
It asks whether the data is the shape the step promised, whether the tool actually answered the question asked, and whether the conclusion follows from the evidence rather than from the model's confidence. A result that passes is cleared. A result that fails is returned, escalated, or marked unresolved, but it is never quietly passed along wearing the appearance of fact.
Its hardest duty is restraint under uncertainty. When it cannot confirm a claim, the correct output is not a softer version of the claim. It is an explicit statement that the claim is unverified. An agent that cannot say it does not know will eventually say something false with total confidence.
How do we say what was verified, and nothing else?
The generator writes the final response. It is the module the reader meets, and the module that must want nothing. By the time material reaches it the hard decisions are made, and what remains is voice: the format the audience needs, the order that makes the finding clear.
It holds one prohibition above all others. It may shape what was verified. It may never add what was not. The executor is bounded in what it may touch; the generator is bounded in what it may assert. It receives a set of verified claims, each with a status, and may render only those claims and those statuses. A claim marked unresolved must reach the reader as unresolved.
This is why voice is the last module and not the first. An institution that leads with how things sound will bend what is true to fit the sentence. Fluency is not honesty. It is the thing honesty must survive.
A language model is at its most dangerous exactly where it is most useful. The generator's talent is fluency, and fluency fills gaps. Asked to summarise four verified findings and one unresolved point, an ungoverned model will smooth the unresolved point into a confident clause, because a smooth sentence is what it was trained to produce. This is where careful architecture upstream is silently undone: in the last room before the exit, where no one is checking any more.
Both failures are visible only against the verifier's record, which is why the generator's output is checked against the claim set it was given rather than against whether it sounds finished.
Four modules mean more calls, more passes over the same material, and more wall-clock time than one model answering in a single breath. That trade is correct when a wrong answer carries a regulatory or financial consequence, and it is simply overhead when it does not. A workflow that summarises internal meeting notes does not need a verifier with binding authority. Apply the full pattern where a decision has to be defended, not everywhere an agent is used.
Drawing four boxes does not make the seams real. If the verifier is the same model with a different prompt, marking its own homework, the pattern is decorative: it will clear what it produced because the confidence that generated the claim is the confidence assessing it. The seams only hold when the verifier's judgment is binding on the generator and when the boundaries are enforced by the system rather than requested in an instruction. A contract nothing enforces is a preference.
PEVG is original work by Dr. Nabeel A. Khan, specified in Prompt Systems and Agent Orchestration, the second book of the Full-Stack AI Engineering Series. That book is forthcoming, out 5 September 2026. This page describes the pattern and its contracts; the book carries the flow object, the training loop for the planner, and a fraud investigation walked through all four roles.
The systems in the series are presented as reference architectures through a deliberately fictional regulated bank, so the method can be shown end to end without exposing a client. The four-role separation itself is not theoretical: it runs in production in Maxim, where an agent that owns customer-facing copy decomposes writing into claims, routes any claim asserting a capability or a limit or a price to a separate specialist whose only function is verification, and treats that specialist's answer as binding. If a claim cannot be confirmed the system does not soften the sentence. It states plainly that the capability is not confirmed and ships the honest version.
Its operational sibling is the PARA operating model, which applies the same separation-of-authority argument to DevOps agents. For how governed agents are deployed inside a regulated enterprise, see agentic AI and MCP governance.
Planner, executor, verifier, generator. The planner decomposes a task into ordered steps. The executor calls tools under a contract that bounds what it may touch. The verifier decides whether a result holds before it is trusted. The generator writes the response and may shape only what the verifier cleared.
Because a system that does everything at once can be held accountable for nothing. When a unified agent returns a wrong answer there is no seam to open: the reasoning, the action, the check and the prose collapse into one trace, and a failure that cannot be located cannot be fixed. Agent systems rarely fail because the model reasoned poorly. They fail because no module owned the failure, so no module could be taught.
The planner. It is where intelligence concentrates and therefore where training pays most, because the plan determines everything downstream. A good decomposition gives the executor clean steps and the verifier checkable claims, while a poor one sends the whole workflow chasing the wrong evidence with perfect tool discipline. The quality of a workflow is decided before the first tool runs.
It is the moment an agent earns the right to be believed. The verifier asks whether the data is the shape the step promised, whether the tool answered the question asked, and whether the conclusion follows from the evidence rather than from the model's confidence. Its hardest duty is restraint under uncertainty: when it cannot confirm a claim, the correct output is not a softened claim but an explicit statement that the claim is unverified.
Not quite, and the difference matters. Many multi-agent systems add agents for capability, so more agents means more things the system can do. PEVG divides one accountability problem until every piece can be named, so more modules means more places a failure can be located. The four roles are not four colleagues. They are four contracts on one workflow.
It is specified in Prompt Systems and Agent Orchestration, the second book of the Full-Stack AI Engineering Series, which is forthcoming on 5 September 2026. This page describes the pattern and its contracts. The book carries the flow object, the training loop for the planner, and the worked fraud-investigation example end to end.
Most agent programmes that stall in a regulated institution stall at the same place: the system works in a demo and nobody can say what happens when it is wrong. The seams are the answer to that question, and they have to be designed before the pilot, not retrofitted after the incident.