---
name: "workflow-venture-operating-loop"
type: workflow
description: 'The standing cycle an operator drives its vertical through — read goal and KPIs, assess, decide, dispatch to the functional fleet via Relay, gate at the mandate edge with the Owner, execute, report, repeat. The operator-tier equivalent of the delivery loop: the delivery loop is what the fleet runs, the operating loop is what drives the fleet toward a vertical''s outcome. Read to see the operator path at a glance, or to render the Layer 4 Workflows layer on the agents site.'
license: CC BY-NC-SA 4.0
---

# Venture operating loop

The Layer 4 workflow for the operator tier (`core-operating-model`, Layer 3). Where the delivery loop moves a single build ticket from Backlog to Done, the operating loop moves a *vertical* toward its mandate outcome, cycle after cycle. It is venture-agnostic: an operator instance (`operator-bara` first) supplies the vertical, its mandate, and its goal/KPI sources; this workflow is the single source for that process — its stages, gates, hand-offs and rules are stated here and are referenced, never restated, by whatever runs them (Owner ruling, Aled, 2026-10-23, APP-2655); the reusable *how* each step invokes stays in `skill-operating-loop`, run on a cadence by a thin `task-*` loader (`task-bara-operator-loop`).

## The path

Three tiers act in the loop. The **Owner** sets the mandate and gates the hard anchors. The **operator** owns the vertical and runs the cycle autonomously within that mandate. The **functional fleet** (Forge, Prism, Reach, Pixel, Sonar, dispatched through Relay) executes. Cross-vertical contention for the shared fleet is arbitrated by **Atlas** for the Owner.

```mermaid
flowchart TD
  A[Read goal + KPIs<br/>vertical strategy, analytics] --> B[Assess vs targets]
  B --> C[Decide next best actions<br/>refresh strategy via Atlas if it has shifted]
  C --> D[Dispatch via Relay<br/>route to the right functional agent]
  D --> E{Mandate edge?<br/>strategic pivot / budget-envelope breach / goal-set change}
  E -- yes --> F[Escalate to the Owner<br/>with a recommendation; hold until ruled]
  E -- no --> G[Proceed autonomously<br/>fleet executes; unflagged ready work promoted]
  F --> G
  G --> H[Report status<br/>progress vs proof points; surface upcoming plans for light Owner review]
  H --> S[Weekly: prepare Owner session<br/>agenda to Aide, book work.Operators; release slot if empty]
  S --> A
```

## The gate, one tier up

The loop reuses the delivery loop's selective gating at the operator tier. Unflagged work proceeds autonomously — the operator is the gate within its vertical. Only the three hard anchors reach the Owner: a **strategic pivot** (a change to positioning or strategy, not a tactic), a **budget-envelope breach** (spend beyond the agreed figure), and a change to the **goal set**. Each is escalated with a recommendation, never actioned unilaterally. Tactical choices — which campaign, which acquisition channel, how to sequence — sit entirely inside the operator's autonomy. The operator does not approve its own merges: Prism's review gate and the delivery-loop merge gate still stand beneath.

## The two cadences and the Owner session (APP-852)

The loop runs at two altitudes. **Daily**, the operator runs a light *shadow stand-up* — yesterday's movement, blockers, and new requirements — that feeds Aled's own 09:00 stand-up (managing down). **Weekly**, it runs the full cycle above and prepares a strategic agenda for the Owner — goals, strategy, concerns, and the mandate-edge escalations — booked into the `work.Operators` window (`convention-hold-windows`) by **Aide**, the single calendar writer; an operator with no agenda that week releases the slot. The weekly session is the managing-up counterpart to the daily managing-down pass; the step detail is stated here and in the sections above, not deferred to `skill-operating-loop`.

## The single source for this process

**The workflow is the single source for a standing process (Owner ruling, Aled, 2026-10-23, APP-2655).** The stages, gates, hand-offs and rules of the venture operating loop are stated in this artefact. A `task-*` or `routine-*` that runs it on a schedule **references this workflow and adds only what is specific to running it** — cadence, surface, run budget, the stop conditions of one run — and does not restate the process. Where a running artefact and this workflow differ, this workflow governs.

**A reusable *how* inside a step stays in its skill.** `skill-operating-loop` is not retired by this rule. The workflow invokes it for the how of its steps; it does not absorb it. It survives **slimmed**: the process content above is the workflow's, and what remains its own is the reusable craft a step calls on. Two reasons for keeping it, both observed in live canon on 2026-10-28: **42** artefacts cite `skill-operating-loop` by name (`grep -rlF` across the synced store, excluding the artefact itself) — the note's figure of 44 was **re-counted** and is corrected here — and the five `task-*-operator-loop` loaders are **inside** that 42, not additional to it. Retiring it would force 42 re-points in a single package, against the same batch-size concern that split this change.

**The reference side is deliberately deferred.** This change states the rule and fixes the direction of reference on the workflow side. Removing the restated process from `routine-delivery-loop` (132,925 bytes) and `skill-operating-loop` (142,019 bytes) is a separate package on a later run, because of the size of the two largest artefacts in canon. A second reason held when this was written, the then-unlanded rename of `skill-exec` / `skill-qa` / `skill-merge` to `skill-build-ticket` / `skill-review-pr` / `skill-merge-pr` (APP-2651), which bound `routine-delivery-loop`; that rename has since landed and no longer gates the package. Until that package lands, a reader meeting the process in two places reads this workflow as the source.

## Composition

* **Behaviour:** `skill-operating-loop` (L1) — the inner cycle.
* **Deployment:** `task-bara-operator-loop` (L2) — the weekly thin loader for BARA; further verticals gain their own loaders as the role rolls out.
* **Roles:** the operator (`operator-bara`), the Owner (Aled), the functional fleet via Relay, Atlas for cross-operator arbitration.
* **Relation to the delivery loop:** the operating loop *drives* the delivery loop — it decides what work exists and dispatches it; the delivery loop *runs* that work from Backlog to Done.
