6. Agent Deployment Patterns as Governance Configurations

(Normative)

6.1 The Structural Observation

Production agent deployments are empirically observed to cluster into distinct patterns — termed “species” in operational discourse (Jones, 2026). These species differ in where humans are positioned, what quality gates apply, how intent is communicated, and how much process structure is needed. This clause provides the structural explanation: each species is a different governance configuration across the three layers.

The five Intent Primitives (Purpose, Direction, Boundaries, End State, Key Tasks) SHALL be present — explicitly or implicitly — in every deployment pattern. When a primitive is absent, the deployment pattern fails. This is the same structural finding the Intent Stack established through seven independent theoretical traditions: five is necessary and sufficient. The species taxonomy provides additional operational evidence for this structural claim.

6.2 Species Definitions

6.2.1 Coding Harness (Individual)

Operational description. A single LLM agent operating as a developer substitute. The human provides tasks, the agent executes, the human reviews output. The simplest agentic pattern.

Governance configuration.

Dimension	Configuration
Intent communication	Informal, per-task, natural language from human manager
Quality gate	Human judgment throughout — direct inspection of output
Human position	Throughout — tight feedback loop
Delegation depth	Single level (human to agent)
Trust calibration	Low to moderate — human retains moment-to-moment oversight

Intent Primitive mapping.

Primitive	Manifestation
Purpose	Implicit in task context — usually obvious from conversation
Direction	Informal — “fix this bug,” “add this feature”
Boundaries	Implicit — scoped by file access, tool availability, developer oversight
End State	Developer’s judgment — “does this look right?”
Key Tasks	Single task per agent, explicitly assigned

BPM/Agent Stack contribution. Minimal. This is task-scale work. The RACI matrix is trivial (developer = Accountable, agent = Responsible). Process structure adds overhead without proportional value. The simplicity is the feature.

Governance interface count. One. Human to agent.

Runtime Alignment mechanism. Human eyeballs — direct inspection of agent output. This is Intent Stack L1 (Runtime Alignment) in its simplest form.

6.2.2 Coding Harness (Project-Scale)

Operational description. A planner agent decomposes project-level work and manages executor agents. The agent is the manager, not the human. The human operates at edges and checkpoints.

Governance configuration.

Dimension	Configuration
Intent communication	Planner decomposes project intent into task-level specifications for executors
Quality gate	Planner evaluates executor output; human reviews at edges and checkpoints
Human position	Edges and checkpoints — “mostly at the beginning, mostly at the end, with some guidance in the middle”
Delegation depth	Two levels (human to planner to executors)
Trust calibration	Moderate — planner trusted to decompose and evaluate; executors trusted for bounded tasks

Intent Primitive mapping.

Primitive	Manifestation
Purpose	Project-level, defined at start, cascades through planner to executors (Purpose narrows)
Direction	Planner contextualizes per executor task (Direction contextualizes per level)
Boundaries	Project-level constraints inherited by all executors (Boundaries accumulate monotonically)
End State	Project-level criteria derived into task-level success metrics (End State derives)
Key Tasks	Planner decomposes and scopes per executor (Key Tasks scopes to delegation interface)

BPM/Agent Stack contribution. Significant. Swimlanes for responsibility assignment between planner and executors. Gateways for task routing decisions. Subprocesses for governed decomposition — each executor task is a subprocess with its own governance interface. The planner IS an informal process orchestrator; the BPM/Agent Stack formalizes what it does. This is the governance complexity threshold — the point at which informal governance breaks down and structured process governance becomes necessary.

Governance interface count. N+1 (one human-to-planner interface, N planner-to-executor interfaces).

Orchestration mechanism. This is where BPM Orchestration enters — swimlanes, task coordination, dependency management, and synchronization. The BPM/Agent Stack’s Orchestration concern governs what the planner agent does informally.

Runtime Alignment mechanism. Two-level: planner evaluates executors (Intent Stack L1 at the planner-to-executor interface); human evaluates planner (Intent Stack L1 at the human-to-planner interface).

6.2.3 Dark Factory

Operational description. Near-zero human involvement from specification input to eval-passing output. Humans at the edges: design and intent at the top, evaluation and review at the end. The middle is autonomous.

Governance configuration.

Dimension	Configuration
Intent communication	Formal specification at entry — the critical quality gate. Intent must be complete and machine-processable.
Quality gate	Automated eval plus optional human review at exit
Human position	Edges only — design and review, not execution
Delegation depth	Multiple levels, fully autonomous in the middle
Trust calibration	High — earned through evaluation quality and monitoring infrastructure

Intent Primitive mapping.

Primitive	Manifestation
Purpose	Must be explicit and complete — no informal “fix this.” The specification IS the governance document.
Direction	Encoded in specification structure and evaluation criteria
Boundaries	CRITICAL — must be machine-enforceable, not advisory. “Really excellent nonfunctional requirements that are enforceable” (Jones). This is the Boundaries primitive at its most operational.
End State	The eval. If the eval is well-designed, End State is machine-verifiable.
Key Tasks	Specification scope — what the system is authorized to produce

BPM/Agent Stack contribution. Full process structure needed. Governed activities with typed attributes. Gateways for structured routing decisions. Structured exception handling (BPMN event taxonomy) — not generic retry but typed responses to typed failures. Escalation events for conditions exceeding agent authority. Subprocess decomposition for governed delegation. Audit trail for accountability.

Governance interface count. Multiple — governed by specification, not human oversight.

Runtime Alignment mechanism. The automated eval IS Intent Stack L1 (Runtime Alignment) — it checks alignment between intent (specification) and execution (output). This is the deontic checksum principle from the Intent Stack: machine-detectable compliance without understanding content.

Specification mechanism. Critical. Intent Stack L2 (Specification) is where the dark factory pattern succeeds or fails. If intent is not formalized well at L2, the dark factory produces the wrong thing correctly. The BPM/Agent Stack’s governed process model IS the execution specification derived from L2’s authorized Key Tasks.

Intent Formalization. The bottleneck. Intent Stack L3 (Intent Formalization) must complete before execution begins. Dark factories require intent to be formalized completely. Incomplete formalization produces fast, confident, wrong outcomes.

6.2.4 Auto Research

Operational description. An agent optimizes for a metric through iterative experimentation. Not about producing software — about climbing a hill toward a more optimal value. Descended from classical machine learning techniques.

Governance configuration.

Dimension	Configuration
Intent communication	Frozen metric plus human-authored research direction (program.md in Karpathy’s formulation)
Quality gate	Metric improvement — objective, automated
Human position	Design only — define metric, constrain action space, review successful experiments
Delegation depth	Single level (human to optimization loop)
Trust calibration	Narrow but deep — full autonomy within a tightly constrained action space

Intent Primitive mapping.

Primitive	Manifestation
Purpose	Single-dimensional — optimize this metric. A degenerate case of the Purpose primitive.
Direction	Research direction document — how to approach optimization (simplicity preference, one change at a time, etc.)
Boundaries	THE CRITICAL PRIMITIVE. The frozen metric IS Boundaries monotonicity — the agent cannot modify its own evaluation function. The constrained action space (only train.py, not prepare.py) IS boundary enforcement. Auto research works BECAUSE the agent cannot relax its own constraints.
End State	Lower metric value. Implicit: improvements must be real, not noise from overfitting.
Key Tasks	Emergent from hypothesis generation — the agent determines what to try next

BPM/Agent Stack contribution. Lightweight. The experiment loop is a simple process. But Value Stream Mapping performance attributes (cost per experiment, time per experiment, experiments per improvement) and audit trail (which experiments succeeded, which failed, and why) add governance value even in this simple case.

Governance interface count. One (human to optimization loop).

Runtime Alignment mechanism. The frozen metric IS Intent Stack L1 (Runtime Alignment) — automated, deterministic, ungameable because the agent cannot touch the evaluation code.

Structural note. Auto research is an eighth independent convergence point for the five-primitive decomposition (see Intent Stack Annex C.2). Karpathy’s program.md implicitly provides all five primitives. The system works BECAUSE all five are present. Remove any one — particularly Boundaries (the frozen metric) — and the optimization loop degrades: without Boundaries, the agent games its own evaluation; without Purpose, experiments have no objective; without Direction, the agent lacks approach guidance; without End State, there is no success criterion; without Key Tasks (even emergent ones), the agent has no action space.

6.2.5 Orchestration Framework

Operational description. Multiple LLMs with specialized roles, coordinated through handoffs. Each agent has a distinct function: researcher, writer, editor, reviewer. Heavy human involvement at transition points.

Governance configuration.

Dimension	Configuration
Intent communication	Role-specialized prompts per agent plus handoff protocols
Quality gate	Per-handoff human review at critical joints
Human position	At every joint — the heaviest human involvement pattern
Delegation depth	Single level per agent, chained — A to B to C with human oversight at transitions
Trust calibration	Per-agent, per-role — different trust levels for researcher vs. writer vs. reviewer

Intent Primitive mapping.

Primitive	Manifestation
Purpose	Workflow-level purpose cascaded to role-specific purpose per agent
Direction	Role-specific — “you are a researcher,” “you are an editor”
Boundaries	Per-role constraints. The researcher can read but not publish. The editor can modify but not delete.
End State	Per-step deliverable plus workflow-level completion criteria
Key Tasks	Tightly scoped per role — each agent performs one specialized function

BPM/Agent Stack contribution. Maximum. Orchestration IS process management. Every BPM element applies: swimlanes for role separation, gateways for routing decisions (deterministic where possible, not LLM-inferred), events for structured exception handling, message flows for governed handoffs with typed payloads, subprocesses for governed decomposition, controlled vocabulary for semantic consistency across agents, decision models (DMN) for deterministic routing logic, policy linkage for per-step governance constraints. The BPM/Agent Stack contribution is at its highest here because orchestration has the most process structure to govern.

Governance interface count. N (one per handoff point in the chain).

Orchestration mechanism. This IS pure BPM/Agent Stack Orchestration. The BPM/Agent Stack’s swimlanes, message flows, and gateway routing are exactly what orchestration frameworks need and currently lack. The specification’s Orchestration concern is at its most expressive in this species.

Runtime Alignment mechanism. Per-handoff quality checks. Currently human-dependent in most frameworks; the BPM/Agent Stack provides structured acceptance criteria at each handoff. Intent Stack L1 (Runtime Alignment) operates at each handoff boundary.

6.3 The Governance Complexity Gradient

The five species, when arranged by BPM/Agent Stack contribution, form a monotonic gradient of governance complexity:

Species	BPM Contribution	Governance Interfaces	Human Position
Coding Harness (Individual)	Minimal	1	Throughout
Auto Research	Lightweight	1	Design only
Coding Harness (Project-Scale)	Significant	N+1	Edges + checkpoints
Dark Factory	Full	Multiple	Edges only
Orchestration Framework	Maximum	N (per handoff)	Every joint

This gradient has a structural interpretation: the BPM/Agent Stack’s contribution scales with the number and complexity of governance interfaces in the deployment pattern. Species with few interfaces (individual harness, auto research) need minimal execution governance. Species with many interfaces (dark factory, orchestration) need rich execution governance. The BPM/Agent Stack contribution MAY serve as a proxy measure for governance complexity.

6.4 The Generative Claim

The species taxonomy (§6.2) is descriptive — it classifies observed deployment patterns. The three-layer governance architecture (Clause 5) is generative — it tells you how to configure governance for any agent deployment pattern, including patterns that have not yet emerged.

For a novel deployment pattern, the configuration procedure is:

1. Identify the governance interfaces (where is authority delegated?);
2. Determine the Intent Primitive content at each interface (what is the Purpose, Direction, Boundaries, End State, and Key Tasks?);
3. Select the BPM/Agent Stack elements proportional to governance complexity (minimal for single interfaces, full for multi-interface orchestration);
4. Position humans at the trust-appropriate points (throughout for low trust, edges for high trust);
5. Design Intent Stack L1 (Runtime Alignment) mechanisms appropriate to the deployment pattern (human judgment, automated eval, or hybrid).

This procedure generates the five known species as special cases and is applicable to any future species.