Related projects: OpenProse (
@openprose/reactor), NLAHs (Natural-Language Agent Harnesses), AGE Template, nop-chaos-flux (a production-grade implementation of AGE)
AGE methodology series: Attractor Before Harness: A Methodology for Large-Scale AI Development, From Spec-Driven Development to AGE
Starting Point
OpenProse, Natural-Language Agent Harnesses (NLAHs), and Attractor-Guided Engineering (AGE) all try to solve the same problem: what do you do when the output of an AI agent is unreliable?
The first two provide answers at the control layer—OpenProse uses a deterministic runtime so that goals can be precisely maintained, and NLAHs use natural-language documents so that harness policies can be reviewed. AGE asks a question that precedes the control layer: what structure should the control maintain in the first place?
If the direction layer does not exist, better runtimes and clearer harnesses will only cause the overall structure to drift.
OpenProse starts from runtime abstraction—designing a contract language and execution engine that allows AI agents to maintain goals that “remain true” over time.
NLAHs start from the representation medium—externalizing agent harness policies from tangled controller code into editable natural-language documents, interpreted and executed by a shared runtime, the IHR.
AGE starts from the engineering process—designing a document-and-workflow system that causes a human–AI collaboration to converge continuously toward a stable structure.
OpenProse asks: how do you keep a goal invariant? NLAHs ask: how do you make a single agent run follow auditable policies? AGE asks: after the system has been pushed off course, why does it still return to the right direction?
Convention: In this article, “NLAHs” refers to the overall framework proposed in the paper (Natural-Language Agent Harnesses), “NLAH” refers to a single policy document, and “IHR” refers to the shared runtime (Intelligent Harness Runtime).
Fixed Point ≠ Attractor
The core abstractions of OpenProse and AGE correspond to two distinct mathematical objects.
Fixed Point: f(x) = x. When the system is placed at this point, it does not move. The judgment criterion is a strict equality. A fixed point can be stable (nearby points converge to it) or unstable (nearby points move away). The concept of a fixed point does not imply the existence of a basin of attraction.
Attractor: A set (a point, a limit cycle, a strange attractor) such that all initial states in a surrounding region (the basin of attraction) evolve toward it over time. The key property is not “put it there and it stays,” but “start near it and you will be pulled back.” An attractor need not be a single point; it can be a manifold. The system does not need to reach it exactly—as long as the trajectory is within the basin and converging, that is enough.
OpenProse’s fingerprint comparison fingerprint == fingerprint is a fixed-point check: is the output the same as before? If so, it stands still.
AGE’s “system converges toward a stable structure” can be understood in terms of attractor criteria: the system need not reach an ideal state exactly; it is enough that the control mechanism continuously pulls it back toward the vicinity of a stable structure.
One is a state judgment—“has it arrived?” The other is a process judgment—“is the direction right?”
Control Target ≠ Attractor: An Ontological Distinction
Beyond the distinction in convergence mechanisms (fixed point vs. attractor), there is a deeper ontological difference: control target vs. attractor.
Control Target
Once a control framework has been established, a control target defines “where control should aim.” It assumes:
- The control framework itself already exists.
- The executor will act according to the instructions.
- Deviations are corrected by re-executing the instructions.
A control target is an externally imposed specification that drives the executor to conform to it.
Mathematical Attractor
An attractor is generated by the system’s own dynamics—all initial states in the surrounding region converge toward it over time. The key properties:
- It is emergent—defined by the system’s dynamics, not by externally imposed commands.
- Perturb-and-recover—push it away, and the dynamics will pull it back.
- The system does not need to “know” about it—water follows the Lorenz attractor without needing to know it exists.
- It is a manifold defined by equations—it does not enumerate every correct state, only the constraint relationships.
An attractor provides a final cause for control. It exists prior to control, not within it.
Note: AGE’s attractor is only an analogy; it is not a naturally emergent mathematical object but an engineered semantic field: humans define structural constraints, and the workflow converts these constraints into a recovery dynamic that spans sessions. Its criterion is not “absence of external design,” but “whether the recovery after perturbation is driven by a persistent structural field rather than by one-off instructions.”
An Analogy
An operations manual tells workers how to assemble parts. The workers follow the manual, and when they deviate they correct by referring back to the manual. The manual is a control target—it requires the workers to “know” it and to actively execute it.
A gravity well is an attractor—no matter how you push an object, the object’s dynamics naturally pull it back. The object does not need to “know” the gravity well exists.
The Invariants of OpenProse and NLAHs Are Both Control Targets
OpenProse’s Responsibility (Goal/Maintains/Continuity) is an externally defined specification. The runtime detects deviations via fingerprint comparison and re-renders when a deviation occurs. This is a control target plus deterministic execution. Convergence relies on the runtime forcibly re-executing the specification.
NLAHs’ harness pattern (contract + stages + state / validation / recovery / stopping rules) tells the IHR how to organize a single task run. The IHR is not a hard-coded controller but uses runtime policies to interpret the NLAH, translating the clauses into child-agent calls, state updates, validation gates, and artifact contracts. If an agent deviates, what acts are control targets such as validation / recovery / stopping rules, not a natural convergence of system dynamics. “Behavior is flexible but still policy-guided” is not attractor semantics; it is flexible execution under runtime semantic constraints.
AGE’s Owner-Doc System Possesses Attractor-Like Properties by Analogy
- Perturb-and-recover dynamics: AI changes code (perturbation) → test/audit discovers a deviation → correction → the system returns to the vicinity of the structure. The cross-session perturbation–detection–correction cycle constitutes a convergence dynamic.
-
Implicitly defined manifold:
docs/architecture/does not enumerate every correct state; it defines constraint equations. The states that satisfy the constraints form a manifold—local implementations can vary, but the whole is pulled toward the same class of structure. - Cross-session emergence: The long-term convergence produced by hundreds of commits, dozens of plans, and multiple audits is a “system behavior,” not the behavior of a single execution.
AGE’s recovery likewise depends on documents as a source of truth. The difference is not merely granularity and time scale but what is being constrained: control-layer instructions constrain how a single execution is completed; the direction layer constrains the structural region into which the results of all future executions are allowed to fall.
Structural Parallels at the Mechanism Layer
The three systems exhibit structural parallels at the mechanism layer:
| OpenProse | NLAHs | AGE | |
|---|---|---|---|
| Source of truth | Responsibility (Goal/Maintains) | NLAH (contract + run rules) | Owner docs (docs/architecture/) |
| Interpreter | OpenProse reactor | IHR runtime | AI agent reads documents |
| Execution unit | render | task run | plan (for major changes) |
| Detection | fingerprint comparison | validation gates | CI + audit |
| Closure condition | postcondition + receipt | completion gates + artifacts | Closure Gates + independent closure audit |
| Correction | re-render | retry / recovery / honest stop | fix code, re-read documents |
The mechanism slots are similar, but the semantics differ. This table only illustrates that all three are control systems, not that they control the same kind of object. OpenProse and NLAHs make a single execution more controllable; AGE judges whether the accumulation of those executions still points toward the same long-term structure.
The difference lies not at the mechanism layer but in whether a direction layer exists above it. OpenProse’s Responsibility and NLAHs’ NLAH are both self-contained specifications—they define their own completion conditions (fingerprint equality / contract satisfaction) without requiring external reference to “what structure the system should converge toward.” AGE also has completion conditions (CI gates, audit passing), but the irreplaceable role of owner docs is: when a local completion condition conflicts with the long-term structural direction, they provide the adjudication basis. CI can determine whether a particular import passes; owner-doc determines why flux-react must not have a reverse dependency on the renderer package. The former is a control gate; the latter is the direction layer.
This is precisely the distinction between the direction layer and the control layer: it is not a difference of mechanism, but whether there exists above the control an independent, persistent target structure that provides the final cause for all control.
The Ontological Positions of the Three
The relationship among the three is not a hierarchical one (project-level attractor ⊃ run-level attractor), but an ontological difference:
Direction layer (Attractor) — AGE: the long-term convergence structure defined by owner-doc
↑ provides final cause for control
│
Control layer (Control Target) — NLAHs/OpenProse: specification + runtime execution
↑ implements the control mechanism
│
Mechanism layer (Mechanism) — IHR / reactor / CI: concrete detection, execution, recovery
The core thesis of the AGE article is precisely this: the direction layer precedes the control layer. Without defining “where to converge,” control mechanisms have no unified meaning. Both NLAHs and OpenProse innovate at the control layer—NLAHs use NL to improve the auditability and portability of policies, while OpenProse uses a deterministic runtime to improve the precision and cost efficiency of execution. But neither can answer the direction-layer question: Toward what structure should the system converge over the long term? A falsifiable formulation would be: if, after removing AGE’s owner-doc priority chain, logs, and bug distillation, the system can still maintain the same architectural direction during long-term refactoring, then AGE’s direction-layer claim is superfluous.
The Underlying Assumptions of the Three Systems
OpenProse: Sessions Will Eventually End, Responsibilities Should Not Disappear with Them
OpenProse’s core metaphor comes from React. It models every execution of an AI agent as a render.
Three key assumptions:
- The value of AI lies in bounded render—finite, auditable, single-shot reasoning.
- The source of continuity is not the session, but the persistent state of the world-model and the receipt chain.
- Cost is proportional to “surprise,” not to time—if nothing changes, the render does not execute.
This is a runtime-first worldview: first define “what remains true at runtime,” then consider the engineering process.
NLAHs: Policies Should Not Be Buried in Code
The core metaphor of NLAHs (Natural-Language Agent Harnesses) comes from editable policy documents. The NLAH+IHR system splits the agent harness into a four-layer stack.
Three key assumptions:
- Harness policies can be separated from tangled controller code and expressed in editable natural language.
- NL carries the policy, code carries the mechanism—precise operations stay in code, auditable policies stay in NL.
- A shared runtime (IHR) can provide a unified execution substrate for different NLAHs.
This is a representation-first worldview: the representation medium of a policy determines its auditability, portability, and analyzability.
AGE: First Define Where the System Should Return, Then Discuss How to Get Back
AGE’s core metaphor comes from dynamical systems theory.
Three key assumptions:
- AI is a perturbation source structurally different from humans—high frequency, high amplitude, and lacking a sustained sense of direction.
- The attractor must exist before the harness—"where to correct toward" precedes "how to correct."
- Documents are the carrier of the attractor, code is an instantaneous projection of the attractor—neither is the attractor itself.
This is a process-first worldview: first define “toward what structure the system should converge,” then design the runtime behavior.
Summary of Divergences
| Dimension | OpenProse | NLAHs | AGE |
|---|---|---|---|
| Core question | How to make AI continuously maintain a goal that is true? | How to externalize harness policies as auditable NL? | How to make the system continuously converge toward a stable structure under high-frequency AI perturbations? |
| Problem domain | The lifecycle of a single responsibility | The harness policy of a single task run | The evolutionary trajectory of an entire repository |
| Time scale | Single render (minutes) to continuous serve (days) | Single task run (minutes to hours) | Single commit (minutes) to project evolution (months/years) |
| Nature of invariant | Control target (specification + fixed point) | Control target (specification + soft constraints) | Engineered direction field (engineered attractor-like structure) |
| Stability concept | Fixed point—fingerprint equality means no change | Policy conformance—conforming to the policy is correct | Attractor—within the basin means converging |
| Meaning of "correct" | Output matches expectation precisely (binary) | Execution path follows the policy specified by NLAH | The system is moving in the direction of convergence (directional) |
| Control mechanism | Deterministic fingerprint comparison (zero LLM) | IHR interprets NL policy (relies on LLM) | Perturb-recover dynamics (test → audit → fix) |
| Policy enforcement | Enforced by runtime | Runtime + NL guidance | Induced by institutionalized process, not enforced by runtime |
Core Abstraction Comparison
Smallest Primitives
OpenProse’s Responsibility is a self-contained computational unit with explicit input boundaries (Requires), output boundaries (Maintains), a goal (Goal), and a continuity constraint (Continuity). Execution produces a receipt—a content-addressed, chain-verifiable proof of decision.
NLAHs’ NLAH document is an editable policy description that defines the lifecycle policy of a task run: contract, stages, roles, state rules, verification rules, recovery rules, and stopping conditions. A NLAH does not “tell the model how to answer”; it “tells the runtime how to organize a multi-step execution.”
The IHR’s execution semantics do not compile the NLAH into code, nor does it let an agent act freely after reading the document. It uses a fixed runtime-policy prompt to turn the base agent into a parent orchestrator: the parent reads the NLAH and translates the contract, stages, state rules, validation rules, recovery rules, and stopping conditions into child-agent task packets, handoffs, state files, artifact gates, and completion checks. The stages themselves are still executed intelligently by child agents; precise operations such as tests, parsers, validators, and benchmark adapters are handled by scripts/adapters.
AGE’s Attractor is not an object, but a structural property composed of three layers:
-
Structure layer: a small set of high-level invariants (e.g., the package dependency direction
flux-core → ... → flux-renderers, the closure of seven primitives, the compile-first pipeline). -
Carrier layer: auditable documents that carry these invariants (
docs/architecture/). - Implementation layer: the parts of the current code that embody these invariants.
Both Responsibility and NLAH are instances—you can count “this project has 23 responsibilities” or “this benchmark has 1 NLAH.” An Attractor is a property—you cannot count “this project has 5 attractors”; it is more like “the attractor of this system is a low-dimensional manifold.”
All three systems have mechanisms for closing an AI action into a completable unit: OpenProse’s render, NLAHs’ task run, AGE’s plan. The closure of a render is determined by the input fingerprint, postcondition, and receipt; the closure of a task run is determined by the NLAH’s task contract, validation rules, artifact contracts, and stopping conditions; the closure of a plan is determined by Plan Status, Current Baseline, Goals, Non-Goals, the execution/proof checklist, Closure Gates, and an independent closure audit.
A plan is not a to-do list; it is an evidence structure for whether a major change can be closed: first verify the current baseline, constrain the goals and non-goals, prove each item during execution, and finally have an independent audit confirm that the in-scope items have been completed or honestly deferred. The relationship between a plan and the owner-doc is not “update the document every time.” Instead, the owner-doc is used to judge the boundaries and closure conditions of the current change; only when the change alters the live baseline, public contract, or owner behavior does closure require synchronizing the document.
NLAH and AGE plan are similar in mechanism: both use natural language to define the contract, stages, evidence, and stopping conditions, and both oppose relying solely on the agent’s self-reported completion. However, they close different things: NLAH closes a single run, proving that the execution trajectory satisfies the harness policy; plan closes a single change, proving that the results, evidence, and textual state of the current scope are sufficient to be accepted by an independent audit.
| NLAH | AGE plan | |
|---|---|---|
| Target | The harness policy of a single agent run | The closure contract of a single major change |
| Execution structure | IHR parent orchestrator + child agents | Implementing agent / human executing according to the plan; independent reviewer or fresh subagent performs the closure audit |
| Evidence carrier | STATE_ROOT, artifacts, run logs | Plan checklist, proof, verification output, daily log |
| Stopping condition | Task contract, artifact contract, stopping conditions | Closure Gates, in-scope checklist, deferred adjudication, closure audit |
| Handling after failure | In-run retry / recovery / honest stop | Not closing, supplementing proof, changing status, extracting a non-blocking follow-up or new plan |
State Model
| OpenProse | NLAHs | AGE | |
|---|---|---|---|
| State representation | Content-addressed world-model (formal) | Filesystem state (STATE_ROOT + artifacts) | Code + docs + logs (informal) |
| Judgment mechanism | Deterministic fingerprint function (canonicalizer) | Validation gates + artifact contracts | CI commands + human review |
| History | Receipt ledger (chain-verifiable) | Artifact files + logs (within a single run) | Logs + Bug Notes + Git history |
| Stability semantics | Fixed-point detection (hash == hash) |
Policy conformance (conforms to policy) | Attractor convergence (within the basin and direction correct) |
| Cross-session memory | Receipt chain (chain-verifiable) | None (filesystem state within a single run) | Present (logs, bugs, discussions, plans) |
Technical Implementation Comparison
OpenProse is a strict two-phase architecture: at compile time it uses an LLM to produce deterministic artifacts (Forme DAG, canonicalizer, postcondition validators); at runtime it never calls an LLM—all decisions are deterministic. AGE has no “compile once then run” separation; verification is continuously embedded in every change—typecheck → build → lint → test → audit → logs, always verifying the direction. NLAHs sit in between: NL policy is separated from deterministic hooks, but the IHR runtime relies on an LLM to interpret the policy.
AGE explicitly identifies the self-verification trap: when an AI generates both the code and all the evaluation materials (types, tests, docs, completion summary) from the same context, if the understanding is biased, all the “verification evidence” will drift in the same direction. The countermeasure is to force a separation between generation and evaluation—a closure audit must be performed by a fresh context. OpenProse bypasses the same problem by freezing deterministic functions at compile time. NLAHs avoid it in the paper’s evaluation scenarios by relying on a benchmark autograder, but in production deployment they would likewise require an external verification mechanism to avoid the self-verification trap.
Understanding "Consistency"—Three Semantics
This is the deepest point of divergence among the three systems.
OpenProse’s fixed-point consistency: Each responsibility’s render produces a world-model; a canonicalizer derives a fingerprint. If the fingerprint is the same as before, the system is “consistent.” The judgment is binary: equal or not equal, there is no “roughly consistent.” At the composition level, if every responsibility is at its own fixed point and the DAG topology is correct, the entire system is consistent. Bottom-up, each local fixed point composes into a global fixed point.
NLAHs’ policy-conformance consistency: whether the agent’s execution path follows the policy specified by the NLAH. The paper defines metrics such as pattern-preservation, stage-coverage, and artifact-contract compliance to measure this. It is not binary—the NLAH allows flexible execution but requires that the policy structure (stages, roles, validation gates, state rules) be preserved. The paper’s RQ2 found that NLAH preserves recognizable workflow structure (workflow preservation 0.63–0.67, stage coverage 0.57–0.82), but information passing is a primary weakness (handoff recall as low as 0.32).
AGE’s attractor consistency: Not binary. A system can be “mostly near the attractor, but one subsystem has deviated”—this is not “inconsistent” but “within the basin yet off-center.” The judgment criterion is directional: is the system converging toward the attractor or moving away? A single commit can pass all tests (within the basin), but if it introduces an architectural drift (e.g., reversing the package dependency direction), the system’s trajectory is no longer converging toward the attractor. Top-down—even if every module’s tests pass (every local part is at a fixed point), the whole can still drift away from the attractor.
AGE’s original assertion: “All state-level checks can pass, yet the system as a whole is drifting.” Plan 76 of nop-chaos-flux is an example: an attempt to remove the local state mirror of array-editor produced 11 test failures—not because of a single bug, but because the tests themselves had drifted into a temporally coupled state with the old implementation. Every accumulated change had passed review and CI, but from the attractor’s perspective, the test suite had drifted away from a position capable of supporting structural evolution. This is precisely why the attractor concept exists.
This distinction is not a terminological preference:
- Fixed-point methods can only detect “has it arrived exactly?”—they are very weak at distinguishing between “on the way toward convergence but not there yet” and “already deviated.”
- Attractor methods naturally focus on the trajectory’s direction—the system does not need to arrive exactly; it only needs to be converging, and convergence itself is sustainable.
- Fixed points work well in discrete state spaces (like the fingerprint of a world-model); attractors are more expressive in continuous state spaces (like the evolution of an architecture).
- This directly explains why OpenProse uses
hash == hash(discrete equality) and AGE uses “CI passes + docs consistency + architectural boundaries intact” (multi-dimensional convergence signals).
Three Dimensions
Positioning of AI. OpenProse models AI as a bounded render function; its role is executor. NLAHs model AI as an execution system organized by a harness policy: the parent orchestrator interprets the NLAH according to runtime policies, child agents execute concrete tasks—roles are differentiated into orchestrator + executor. AGE models AI as a high-frequency, high-amplitude perturbation lacking a sustained sense of direction; its role is perturbation source + executor—simultaneously constrained and utilized.
Understanding of Documents. OpenProse: *.prose.md is the program; if anything disagrees with the Markdown, the Markdown is correct. NLAHs: an NLAH document is a policy—it specifies “how to do” without directly “executing”; the most auditable parts are separated from implementation details. AGE: documents are the carrier layer of the attractor; code is an instantaneous projection of the attractor; the carrier layer defines where it should return.
Failure Handling. OpenProse: failure produces a failed receipt, immediate, individual, each render recorded independently. NLAHs: NLAH defines Recovery Rules (retry, rollback, evidence); failed artifacts are preserved for analysis but are not distilled across runs. AGE: failure produces a structured Bug Note; recurring failure patterns are distilled into guardrails and escalated along a progressive automation ladder (notes → checklists → heuristic scripts → lint rules → CI gates).
Empirical Evidence of Progressive Automation: The nop-chaos-flux Toolchain
A core thesis of the AGE methodology is: what can be turned into a deterministic check will gradually be extracted from trajectory data into deterministic scripts.
The toolchain of nop-chaos-flux provides complete empirical evidence for this claim. The observed 5-tier progressive automation ladder:
Tier 1: Trajectory capture (Bug Notes + Logs)
62+ bug fix notes, 72 daily dev logs
Tier 2: Pattern distillation (Architecture Guardrails + Audit Rules)
8 guardrails distilled from bugs, 19 dedicated audit rules
Tier 3: Codified review patterns (Skills/Prompts)
24 reusable audit/review prompt templates
Tier 4: Heuristic suspicion scanners (Heuristic Scanners, exit 0)
12 focused audit scanners, informational output
Tier 5: Hard-gate automation (Hard Gates, CI-blocking, exit 1 on failure)
14 hard gate scripts, 30+ ESLint rules, dependency-cruiser, Semgrep, Husky pre-commit
Example A: Build Artifacts Polluting Source Directories
Tier 1 — Bug #23: Residual .js files in packages/*/src/ were silently overriding .ts source files during Vitest runs, causing test failures whose root cause was not in the test code. A total of 102 stale files were found.
Tier 2 — Guardrail #6 “No Build Artifacts In Source Directories” was distilled into docs/references/architecture-guardrails-from-bugs.md, with links to bug evidence.
Tier 5 — scripts/verify-no-src-artifacts.mjs became a hard gate (CI-blocking), while scripts/clean-src-artifacts.mjs provided cleanup capability. The pnpm lint chain runs clean + verify before ESLint.
From bug to CI gate, the full 5-tier ladder was traversed.
A Thought Experiment: Managing nop-chaos-flux with OpenProse or NLAHs
If the architectural invariants of nop-chaos-flux were modeled as OpenProse responsibilities, you would obtain precise runtime change detection, but you would not be able to answer why these invariants should be organized that way or how they should evolve. If plan execution were modeled as NLAHs, you would obtain structured execution workflows, but you could not answer whether, after 100 plans, the system is still converging. Both are control-layer tools; neither covers the direction layer.
AGE’s owner-doc system handles these questions. OpenProse’s responsibility contracts do not cover the direction layer. NLAHs’ policy documents do not cover the cross-session trajectory evolution. Both are excellent control-layer tools, but the attractor (direction layer) falls outside their problem domain.
Conclusion
OpenProse answers: “Given a goal that must continuously remain true, how can we use AI to maintain it efficiently, safely, and auditably?”—a micro-runtime problem.
NLAHs answer: “Given tangled controller code, how can we externalize reusable harness policies into NL documents that are auditable, portable, and amenable to ablation analysis?”—a representation-medium problem.
AGE answers: “Given a system that continuously evolves under AI perturbation, how can we ensure it does not drift away from a stable structure?”—a macro-process problem.
The three safeguard different formal/engineered stability semantics, and even different ontological layers. OpenProse trusts algorithms (deterministic functions, content addressing, chain verification) to maintain a fixed point; NLAHs trust auditable NL policies (IHR interpreting and executing, modules amenable to ablation) to maintain policy conformance; AGE trusts not a generic process but a process that is auditable, cumulative, adversarial-reviewable, and capable of sedimenting failure into future constraints. OpenProse and NLAHs innovate at the control layer; AGE contributes at the direction layer.
The real divergence lies in where failure accumulates: OpenProse localizes failure to a responsibility, NLAHs localize failure to a task run, AGE treats failure as a signal in a cross-session trajectory.
In the practice of nop-chaos-flux, AGE’s progressive automation ladder has already been validated: 62+ bug notes → 8 guardrails → 14 hard gates + 12 heuristic scanners + 30+ ESLint rules. Bug #23 (build artifact pollution) fully traversed the 5-tier distillation from bug note to CI-blocking hard gate. 72 log files record the system’s trajectory, 46 execution plans serve as local convergence mechanisms, and the priority chain of 58 architectural documents is the carrier layer of the attractor.
OpenProse can turn the local invariants that AGE has already made explicit into precise change detection. NLAHs can turn harnesses into objects amenable to ablation. Both are excellent control-layer tools; but the attractor (the direction layer) falls outside their problem domain. They can serve as control-layer executors; they cannot replace a direction-layer judge.
One could put it this way: if a project continuously passes CI, review, and harness contracts, yet after 50 AI-assisted changes exhibits package boundary reversals, semantic test coupling, and owner-doc conflicts, then the control layers of OpenProse/NLAHs have succeeded—and the problem that AGE is designed to address has only just become visible. That is the dividing line among the three: not who is more comprehensive, but who can see the long-term drift.
The control layer can tell AI how to correct an error; the direction layer determines what counts as an error in the first place.
Top comments (0)