Executive summary

The choice between Mode 1 (augmentation inside the existing lifecycle) and Mode 2 (agentic loops that collapse it) is a per-work-pattern decision that varies by architectural domain. It reduces to five variables, each a spectrum rather than a switch: spec precision, verification surface, training-corpus depth, platform foundation, and risk tier. When the five align, Mode 2 ships. When they diverge, Mode 1 holds. The cases that matter sit in the middle, where two or three variables favor autonomy and the rest do not, and that is where pattern discipline pays. Platform foundation is the variable that decides most often. The clearest proof is that one data team runs Mode 2 on dbt transformations and Mode 1 on complex Airflow orchestration: a single toolchain, opposite calls. This article maps the five variables across software domains and turns the series into a decision instrument.

At the helm

Parts 2 and 3 built both engines and proved each in production. What remains is the navigation skill: reading the chart before the jump. A helm officer favors neither the warp drive nor the impulse engine. The officer reads the heading, the field, and the risk, then engages the propulsion the route allows. Mode selection is the same discipline, and it resolves to five readings. 🖖

Five variables decide

Each variable is a continuous spectrum, and the composite position across all five determines fit. None is binary, and none settles the call alone.

Spec precision. Mode 2 runs on the spec, so deterministic success criteria, typed contracts, and reference implementations push a pattern toward autonomy, while subjective or emergent requirements pull it back to a human in the loop. A long autonomous session on a vague spec spends compute to build the wrong thing.

Verification surface. A loop is only as safe as the check that closes it. Mechanical verification (compilers, type checkers, tests, linters) decides pass or fail without a person; taste-based verification cannot. The cleaner the surface, the deeper an agent can iterate unattended.

Training-corpus depth. Models know a language in proportion to its public footprint. TypeScript, Python, Java, and Go run deep; Tandem TAL, RPG, and niche DSLs run shallow. ABAP sits in between, where SAP’s Joule, trained on hundreds of millions of lines, closes a gap inside SAP’s own ecosystem that a general model cannot.

Platform foundation. Component catalogs, ownership metadata, comprehensive tests, standardized builds, and fleet orchestration are what let a loop run without producing noise at speed. This is the dominant variable, and it is independent of codebase size: structural standardization decides, not raw scale.

Risk tier. Part 3’s action tiers return here as a selection input. Read-only operations are always safe, bounded writes are conditionally safe, and irreversible operations such as production deploys, schema changes, and deletions stay approval-required no matter how Mode 2 the surrounding work looks.

The composite reading is a judgment about alignment across the five, not an additive score. Align them and Mode 2 works; diverge and Mode 1 is the only safe pattern. The framework diagram plots two real patterns on the five spectra, one aligned and one divergent.

The corridors, walked

Three contrasts show the variables at work, each making one point. They run from the clean Mode 2 wins to the splits inside a single toolchain to the legacy estates where tooling decides.

Modern integrations are deep Mode 2 territory. REST and gRPC services, ORM-backed databases, and message queues align all five variables at once: typed contracts, contract tests, deep corpus, standard platforms, conditionally-safe operations. The loop closes cleanly and the agent earns real autonomy.

The same toolchain can split down the middle. Inside one data stack, dbt transformation logic is among the strongest Mode 2 fits because dbt tests and Great Expectations make verification mechanical, while complex Airflow orchestration stays Mode 1: branching, dynamic task generation, idempotency, and partial-failure recovery defeat an agent that does not reason about them. The split follows the pattern, not the team that owns both.

Legacy and vendor estates turn on tooling, not age. A mainframe paired with IBM’s watsonx Code Assistant for Z, with input-output equivalence as the verifier, is Mode 2-viable, while Tandem TAL, with no training corpus and no vendor agent, is Mode 1 only. The rule for vendor platforms is direct: use the vendor’s own AI tooling where it exists, such as SAP Joule or ServiceNow’s Build Agent, and default to Mode 1 everywhere else.

The matrix ranks patterns by Mode 2 viability, from modern integrations at the top to narrow legacy at the bottom, each paired with the harness or vendor tool that makes the call. One caveat governs the read: every domain still supports Mode 1 augmentation, so the ranking marks where autonomy is additionally viable, not where Mode 1 ends.

Pilot before rollout

The framework is a directional aid rather than a measurement instrument. Validate each pattern’s position against pilot results before scaling, using five steps:

1. Inventory work by pattern, not by codebase, and place each pattern on the five-variable map.
2. Identify the vendor tooling for each platform, since SAP, ServiceNow, and IBM Z tooling moves the corpus and platform variables a general model cannot.
3. Audit the verification harness per pattern, and strengthen weak harnesses before attempting Mode 2.
4. Set the risk tier explicitly per pattern: read-only to auto-execution, conditionally-safe to verification gates, approval-required to a human gate.
5. Run domain-specific pilots before generalizing, on the four-to-six-week cadence from Part 3, because a Mode 2 win on dbt does not carry over to Airflow.

One principle ties the toolchain together: evaluate the model-harness pair rather than the model alone, and treat the harness as portable infrastructure. AGENTS.md now sits under the Linux Foundation and the major harnesses have converged on one blueprint, so the scaffolding moves between tools instead of locking to one.

The portfolio close

The mode decision is per work pattern, and the organizations that win the next 20 to 26 months run both engines deliberately. The timing sharpens the point. The tooling layer is consolidating and vertically integrating at once: at Cursor’s June 16 Compile event, SpaceX announced a $60 billion all-stock acquisition of Cursor’s parent and a frontier model trained alongside it, plus Origin, a git forge built for agents rather than people. The same month, AGENTS.md moved under the Linux Foundation and the leading harnesses converged, even as Anthropic paused its June 15 agent-pricing change on the day it was due. The instruments are in motion; the five variables are not.

Each engine’s full playbook anchors its own article in this series, and the cross-domain guide behind this piece carries the per-domain detail. Read together, they answer one question for every piece of work.

Pick the mode by the work pattern, not by the team’s enthusiasm.