Early instructions carry less weight as a session grows. A rule stated at turn 1 may be ignored by turn 9 without any warning.
This tendency varies by model and session length: measure it on the actual setup. Long-context use is less reliable than short-context use, so drift is expected rather than surprising.
Session stage | Typical behaviour | Answer |
|---|---|---|
Early turns | Constraints are followed | State each rule once, plainly. |
Middle turns | Some rules weaken | Restate the contract beside the current work. |
Late turns | A rule may drop silently | Rescan the output against the contract. |
Restatement puts the rules back near the work. A short rule list repeated every few turns costs little and holds the session inside its contract.
session of 12 turns, restate the contract every 4 turns (stated example policy)
restatements = 12 / 4 = 3, at turns 4, 8 and 12
scan cost: assume each turn check costs 2 units (labelled EXAMPLE parameter)
scan total = 12 x 2 = 24 unitsKeep the contract as a written list and scan each output against it. The program below scans a 12-turn record where turn 9 drops a required rule.
import sys
CITES = [True, True, True, True, True, True, True, True, False, True, True, True]
def main():
if len(CITES) != 12:
print("FAIL: turn count is " + str(len(CITES)))
sys.exit(1)
gaps = [i + 1 for i, c in enumerate(CITES) if not c]
if gaps != [9]:
print("FAIL: gap list is " + ",".join(str(g) for g in gaps))
sys.exit(1)
print("PASS: 12 turns scanned, dropped rule at turn 9 located")
main()Twelve entries go in and one gap comes out. The scan locates the dropped rule at turn 9, which restatement at turn 8 was meant to prevent.
A rescan of all 12 turns against the stated contract. The scan locates the gap at turn 9.
Later turns drift from early instructions. Restatement keeps the rules near the work instead of buried far above it.