Give AI agents the same governed operating model as people.
Engineering agents can understand code, tickets, and documentation. What they cannot infer is which process applies, what “done” requires, what they may decide, and where a human must approve.
- Code
- Tickets
- Docs
- Which process applies here
- What “done” requires
- What it may decide
- Where a human must approve
A new executor in processes designed for people.
Agentic engineering introduces a new executor into processes designed for people. Agents can already analyse, implement, test, and document changes. But the rules governing that work often still live separately in process documentation, prompts, checklists, and people's heads.
The agent can do the work. It does not automatically know the conditions under which the work is allowed to be done.
- The agent knows the task, but not necessarily the effective process for this context.
- Process rules and agent instructions can drift apart.
- Human checkpoints often rely on the agent being told to stop.
- Different agent configurations can apply the same process differently.
- Provenance may show what happened, but not which process and authority governed it.
Why the conventional approach falls short
Giving an agent more information is not the same as governing it.
Retrieval provides text, but does not resolve or enforce the process that applies here.
Every prompt becomes another place where the operating model must be maintained.
Human judgement remains essential, but reviewing everything removes much of the benefit of autonomous execution.
The operating model governs the agent.
The platform resolves the effective process for the task and turns it into machine-readable agent instructions and controls. The process determines what the agent must do, what “done” means, what it may decide, and where execution must stop.
Applicable activities, inputs, outputs, and guidance become contextual instructions for the agent.
Required artefacts, sequencing, applicability, and authority boundaries are explicit rather than buried in prompts.
Tests, required artefacts, traceability, Definition of Done, and other machine-checkable conditions can be enforced deterministically.
Where judgement or approval is required, the agent can prepare and propose but cannot proceed on its own.
Agent actions remain tied to the process version, controls, tools, and approvals under which they occurred.
How governed agent execution works
- Resolve the effective process
Determine what applies to this task based on product, project, change type, risk, role, and tailoring context.
- Compile agent instructions
Turn the effective process into skills, Definition of Done, authority boundaries, permitted tools, and human checkpoints. Machine-checkable conditions can become deterministic rules.
- Execute inside the guardrails
Let the agent perform the work while hooks verify conditions such as passed tests, required artefacts, updated traceability, or completion of the Definition of Done.
- Stop where humans must decide
When the process requires judgement, independent review, or approval, execution stops. The agent can prepare the decision; the accountable person makes it.
- Retain provenance
Record the process version, applicable controls, agent actions, checks, tool use, and human approvals associated with the work.
The process becomes an enforceable Definition of Done.
A coding agent can implement the change autonomously. The process determines when it may call the work complete.
An AI coding agent fixes a defect in a safety-relevant component. The effective process defines a task-specific DoD: impact analysed, tests passed, traceability updated, and safety approval obtained. Deterministic hooks enforce the checkable items; when the safety decision is reached, the agent stops for human approval.
One operating model. Different executors. The same governance.
People and agents work from the same effective process. Machine-checkable rules are enforced automatically, human judgement remains with people, and execution stays traceable to the model that governed it.
Agents that work inside your operating model — not alongside it.
Scale agentic engineering without creating a separate process system for AI. Agents get the right process for the task, operate within explicit boundaries, and stop where humans must decide.
- Right process for every task
- Executable Definition of Done
- Provable agent execution
Product capabilities behind this use case
Giving an agent the process that applies, handing it over in a form the agent can read, and keeping the controls and the record that make the result reviewable.
Questions we get
- How does an engineering agent receive the process?
- The effective process is compiled into machine-readable context and controls: activities, inputs, rules, authority boundaries, permitted tools, and checkpoints.
- Does the AI decide what it is allowed to do?
- No. Authority comes from the governed operating model. Where the process requires human judgement or approval, the agent cannot make that decision itself.
- Are the guardrails just prompts?
- No. Guidance can become agent context, while machine-checkable process conditions can be implemented as deterministic rules or hooks.
- Does this require a specific agent platform?
- No. Process context and controls can be exposed through the integration mechanisms supported by the agent, such as APIs, MCP, rules, or hooks.
- Do we need agents to use the platform?
- No. The same operating model governs people first. Agent instructions and controls are derived from it when agents are introduced.
Need help governing agent execution?
PEDCO can derive the agent's rules and controls from your process and engineer the operating model they come from — the agentic work and the process work it depends on.
Make the operating model executable — for people and AI agents.
Book a walkthrough