LEN-0170
Convergence Lens
Compares parallel structural systems to determine whether they align under shared authority.
Primary Pattern Matches
Asymmetric Structure
A structural condition where comparable regions receive unequal rule, constraint, or authority application without a declared differentiation rule.
Lens Application
The Convergence Lens is a strong inspection mechanism for Asymmetric Structure because it tests whether comparable structural systems align when governed by the same authority. It helps reveal where rules, constraints, approvals, or permissions diverge across parallel regions without an explicit basis for differentiation.
Inspect For
- Comparable regions subject to different rule applications
- Shared authority producing divergent approval paths
- Constraints applied unevenly across parallel systems
- Local exceptions lacking declared criteria
Avoid
Unequal treatment should be read as an inspection signal rather than confirmation that asymmetric structure is present.
Contract Drift
A structural condition where a declared contract changes but connected structures, implementations, consumers, or expectations do not update in sync.
Lens Application
The Convergence Lens is a strong inspection mechanism for Contract Drift because it places related structures side by side and checks whether declared contracts, implementations, consumers, and operational expectations still converge under the same authority.
Inspect For
- Divergence between declared contract and implemented behavior
- Consumers relying on outdated assumptions
- Parallel documentation, schema, API, or workflow mismatch
- Authority updates applied unevenly across connected structures
Avoid
Treat divergence as an inspection signal requiring follow-up, not proof that Contract Drift is fully present.
Convergence Failure
A structural condition where sequential or parallel states fail to resolve into an equivalent or coherent structure under shared authority and constraints.
Lens Application
The Convergence Lens is a strong inspection mechanism for Convergence Failure because it tests whether sequential or parallel states resolve into equivalent, coherent structures. It highlights where authority, constraint sets, or resolution paths diverge enough to prevent reliable convergence.
Inspect For
- Parallel states that produce incompatible outcomes
- Shared authority failing to reconcile structural differences
- Constraint sets applied unevenly across systems
- Resolution paths that remain structurally misaligned
Avoid
Treat divergence as an inspection signal requiring further analysis, not confirmation that Convergence Failure is present.
Divergent Outputs
A structural condition where parallel evaluations under comparable scope and shared authority produce non-equivalent outputs.
Lens Application
The Convergence Lens is a strong inspection mechanism for Divergent Outputs because it compares parallel outputs across comparable scope, authority, criteria, and process conditions. It helps surface where outputs diverge, whether divergence follows a structural pattern, and which shared-authority assumptions require closer inspection.
Inspect For
- Parallel evaluations producing materially different outputs
- Shared authority or criteria applied inconsistently
- Comparable scopes yielding non-equivalent conclusions
- Process or interpretation gaps across evaluation paths
Avoid
Treat output mismatch as an inspection signal, not conclusive evidence of Divergent Outputs, until scope, authority, criteria, and process conditions are checked.
Secondary Pattern Matches
Authority-State Mismatch
A structural condition where observed system state no longer aligns with the declared authority state that is supposed to govern it.
Lens Application
The Convergence Lens applies indirectly to Authority-State Mismatch by showing whether systems under the same declared authority framework are converging, diverging, or maintaining inconsistent observed states. Divergence may suggest areas where declared authority is not being consistently reflected in practice.
Inspect For
- Parallel units governed by the same authority but showing different states
- Repeated divergence after common directives or controls
- Local adaptations that conflict with declared authority state
- Alignment in documentation but mismatch in observed operation
Avoid
Treat convergence gaps as inspection signals, not evidence that Authority-State Mismatch has been established.
Non-Deterministic Execution
A structural condition where equivalent inputs and declared constraints produce divergent outputs across executions.
Lens Application
As a secondary lens, the Convergence Lens helps inspect Non-Deterministic Execution by checking whether equivalent executions converge on structurally consistent outcomes. It may surface divergence across parallel systems, repeated runs, or comparable decision paths, especially where shared authority should produce aligned behavior.
Inspect For
- Divergent outputs from equivalent inputs
- Parallel executions that fail to align
- Inconsistent interpretation of shared constraints
- Authority boundaries applied differently across runs
Avoid
Treat convergence gaps as signals for further inspection rather than evidence that Non-Deterministic Execution has been established.
Related Issues
Actual Policy Differs From Declared Policy
The policy the AI or workflow actually follows differs from the policy that is documented, declared, displayed, or expected.
Agent Keeps Expanding the Task
The agent repeatedly expands the task, plan, scope, or next-step list instead of completing the declared work.
Agent Never Settles on Final Answer
The agent keeps revising, rechecking, planning, or branching instead of converging on a final answer or completed result.
AI Forgets Earlier Constraints
A constraint, instruction, preference, or decision that should persist through the task stops affecting later output.
Behavior Does Not Match Declared Role
The AI or agent behaves outside, below, or differently from the role, authority, responsibility, or permission posture declared for it.
Cannot Identify Authoritative State
The user or workflow cannot tell which state, version, review result, decision, source, or output is currently authoritative.
Context Changes After Restore
Restoring, reopening, resuming, or reloading a task changes the context that the AI uses to continue the work.
Declared Owner Cannot Control Outcome
A person, role, system, or policy is declared responsible for an outcome but does not have the actual authority or control needed to govern it.
Early Model Output Gets Overweighted Downstream
An early AI output receives too much authority in later workflow steps, decisions, reviews, or generated artifacts.
Human Review and Automation Disagree
A human review result and an automated AI or workflow result disagree without a declared rule for resolving the difference.
Local Exception Grows Into Policy
A local exception, special case, or one-off allowance begins to function like a general policy.
Merge Step Leaves Unresolved Differences
A merge, reconciliation, or consolidation step combines outputs or reviews but leaves important differences unresolved.
Model and Workflow Disagree on Next Step
The AI model recommends or selects a next step that conflicts with the workflow state, required handoff, routing rule, or process sequence.
No Owner for Agent Action
An agent action can affect the system without a declared responsible owner, authority, or accountable decision path.
Old Output Expectations Survive Migration
Expectations from a prior model, prompt, schema, tool, or workflow survive a migration and continue shaping review or downstream handling after they should be replaced.
One Prompt Carries Too Many Meanings
A single prompt carries too many meanings, goals, roles, constraints, or implied tasks for the AI to interpret consistently.
Output Breaks After Model Change
Output that previously worked begins failing after a model, mode, runtime, or product behavior changes.
Output Changed Without Declared Change
Output shape, content, format, fields, or behavior changes without a declared change to the prompt, schema, model, workflow, or governing rule.
Parallel Reviews Never Agree
Parallel AI, human, workflow, or tool reviews keep producing different results without resolving into a shared decision state.
Policy Update Not Reflected in Output
A policy, rule, standard, or instruction has been updated, but the AI output still follows the older version.
Prompt Behavior Changed Without Version Change
A prompt begins producing different behavior even though no prompt version, model version, workflow version, or declared dependency change is recorded.
Prompt Changed but Workflow Did Not
A prompt changes but the workflow, parser, review step, routing rule, or downstream expectation still assumes the old prompt behavior.
Prompt Has Too Many Valid Interpretations
The prompt allows too many reasonable interpretations, causing the AI to choose among valid paths without enough guidance.
Prompt Only Works After Retry
The prompt fails, misroutes, or produces an unusable response on one attempt but works after retry without a meaningful change to the input.
Results Vary Too Much
Repeated or comparable runs produce outputs that vary more than the task, workflow, or user can tolerate.
Review Escalates Without Stop Condition
A review process keeps escalating, re-reviewing, or adding scrutiny without a declared condition for stopping.
Review Queue Becomes Bottleneck
A review queue, approval path, or validation stage accumulates too much work and begins blocking the workflow.
Revoked Approval Still Treated as Active
An approval, permission, exception, or authorization that was revoked continues to affect AI behavior or workflow decisions as if it were still active.
Routing Overrides Task Intent
Routing, mode selection, agent behavior, or workflow classification sends the task down a path that overrides what the user was trying to accomplish.
Routing Path Cycles Back to Start
A routing path sends the case back to the starting point or an earlier step without resolving the condition that caused the route.
Rubric Changed but Results Did Not
A review rubric, scoring rule, evaluation standard, or classification criterion changes, but AI results continue to reflect the old rubric.
Same Contract Name Has Different Meanings
The same prompt, schema, field, policy, tool, or workflow contract name is used in different places with different meanings.
Same Instructions Allow Different Outputs
The same instructions are broad or underspecified enough to allow materially different outputs that all appear compliant.
Same Rule Declared in Multiple Places
The same rule, constraint, instruction, or policy appears in multiple places, creating redundancy and possible drift.
Same Workflow Check Happens Twice
The same review, validation, approval, routing, or safety check occurs more than once in the workflow without a clear reason.
Saved Reference No Longer Works
A saved source, citation, file reference, prompt reference, or workflow pointer previously worked but no longer resolves to the expected object or meaning.
Similar Cases Route to Different Outcomes
Similar inputs, cases, prompts, or workflow states are routed to different outcomes without a declared difference that explains the split.
Small Change Produces Large Downstream Effects
A small prompt, schema, policy, output, or workflow change creates unexpectedly large effects in downstream steps.
Stale Context Affects Output
Old context, prior instructions, outdated references, or earlier task state continue to affect output after they should no longer apply.
Task Progress Is Lost Midway
The AI loses track of completed work, prior decisions, current position, or remaining steps before the task is finished.
Tool Result Not Integrated Correctly
The AI receives a tool result but misreads, ignores, overwrites, misplaces, or fails to incorporate it correctly into the final output or workflow state.
Validation Result Changes on Retry
A validation, grading, review, classification, or pass/fail result changes after retry even though the input and declared validation rules did not change.
Version Change Breaks Existing Prompt
A prompt that previously produced usable results stops working after a version change in the model, tool, policy, schema, product surface, or workflow.
Workflow Loops Through Review Without Resolution
A workflow repeatedly sends work through review, repair, or escalation without reaching an approved, rejected, or otherwise resolved state.
Workflow Waits on Step That Waits Back
A workflow step waits for another step that also waits on the first step, creating a blocking loop.