I want my harness — the system of context, contracts, memory, tools, validation, and limits around a model, the component that transforms inputs into outputs — to learn.

I want it to notice when guidance appears again, when a gap keeps wasting time, when a contract no longer explains what is happening, and when a recorded decision is no longer reaching the people or systems that need it.

I just do not want it to confuse that with permission to rewrite history while nobody is watching.

Because continuous learning without origin, confirmation, or a trail is a telephone game with write access — permission to change stored files or data.

A sentence starts as an observation. Another agent — a system that chooses steps and uses tools within defined limits — summarizes it. A third one reuses that summary. Soon, something that may have been an impression from one afternoon is governing a rule, an answer, a workflow, or a priority. Not because someone decided it should. Because nobody stopped to ask.

TL;DR

My harness can detect repetitions, gaps, and contradictions. But a signal does not become current memory, and memory does not become a rule, by itself. The flow I am building is: observation → recorded hypothesis → affected consumers — files, rules, and other artifacts that depend on that conclusion — → change proposal → author confirmation or rejection → traceable update → validation and rollback — undoing a change and recovering a previous state if it goes wrong. Skills — reusable procedures with inputs, limits, and verification —, wiki pages — worked, connected, and revisable knowledge —, memory, contracts, and Git — a version-control system that records and compares changes — can evolve together without the system silently rewriting the past. Learning here does not mean unlimited autonomy. It means getting better at showing me what deserves a decision.

Storage does not make the telephone game more reliable

The telephone game is funny because the sentence that arrives at the end is so distorted that no one knows where the transformation began.

In an artificial intelligence (AI)-assisted operation, it can be less funny. The distorted sentence may arrive with a technical tone, links, a checklist, and the confidence of someone who just rediscovered an ancient truth.

The danger is not summarizing. Summaries make it possible to continue a conversation, switch agents, and avoid reopening every project file every time. The danger is losing the label on what was summarized.

That was the issue when AI forgot exactly what I had already decided. Compacted context can be useful. It still does not decide which instruction remains in force.

Continuous learning adds a second layer: the system begins to look for patterns in what happened. If it cannot distinguish an observation from a decision, it treats repetition as authorization.

And repetition is weak evidence for many things.

A preference may have been circumstantial. An exception may have become an example. A sentence used to test a scenario may have been saved as a rule. An agent behavior may be repeating because an old contract is prompting that repetition.

The system does not need to forget those signals. It needs to know they are still signals.

Five things that look alike until they cause damage

I separate at least five objects. The distinction sounds bureaucratic until a correction has to reach everything it affected.

Object	What it is	What it cannot do alone
Memory	Useful continuity about what happened and where work stopped	Define a current rule
Fact	Something confirmed by a source, test, or owner statement	Claim more than its evidence supports
Hypothesis	A plausible reading that still needs a verdict	Become true through repetition
Decision	Direction adopted by the person accountable for consequences	Become permanent law without review
Current rule	An instruction applicable to a context and canonical source	Hide origin, scope, exceptions, or review date

This is a more operational version of what I wrote in A Hypothesis Does Not Become Fact Because AI Repeated It. That article examines improper promotion of a hypothesis. This one asks another question: how can a system learn from what it sees without making that promotion in secret?

Memory can say that a conversation ended with a recurring question. Good: that is a lead for investigation.

It cannot decide, on its own, that the question became policy.

Learning means proposing a bounded change

When the harness detects a repetition or a gap, I do not want it editing whatever it finds. I want it to prepare a reviewable proposal.

The minimum cycle is:

1. Observed signal. A decision was repeated, an agent had to ask the same question, a validation failed, or a gap resurfaced.
2. Recorded hypothesis. The system states what it thinks is happening, showing origin, supporting evidence, contrary evidence, and proportional confidence.
3. Mapped consumers. It identifies which skills, wiki pages, memories, contracts, workflows, or agents may be affected.
4. Proposal. Instead of editing everything, it suggests the smallest change able to reduce repetition or ambiguity.
5. Confirmation or rejection. I accept, correct, narrow, or reject the hypothesis.
6. Traceable update. The change reaches the correct owner, linked to the decision and reviewed consumers.
7. Validation and rollback. The system checks whether the rule worked and keeps a clear way to undo the change if reality answers differently.

The important part is the fourth step.

It is not “the harness learned and updated itself.” It is “the harness found something that may justify an update and prepared it for review.” Less magical, because it is less magical. Far more reliable too.

A rejected hypothesis should remain visible

A rejected hypothesis should not evaporate as if it never existed.

It needs to retain, at minimum, where it came from, what it suggested, who could be affected, and why it was rejected. Not to win the discussion later, but to keep another agent from rediscovering the same thing with less context and presenting it as new.

This is where a wiki helps. Not as infinite memory, but as a place for worked knowledge: hypotheses, decisions, syntheses, and their relationships.

In my case, the wiki does not replace the contract that governs a file or workflow. It preserves the path that explains why that contract exists, which alternatives were discarded, and under what condition it should be revisited.

Nor does it replace memory. Memory is work continuity. A wiki is knowledge that deserves to be found and reconsidered. Mixing them is a good way to build a huge drawer where nothing is discarded and nothing has precedence.

Every component learns differently — and has a boundary

A skill is a reusable procedure. It can learn that a step always needs the same verification and propose making that verification part of its flow.

A contract such as AGENTS.md can learn that agents are getting lost in one part of a project and point more clearly to the source of truth. But it must remain a readable entry point, not a dump of everything that ever happened.

Memory can learn that a topic is recurrent and suggest where to find the current decision. It should not carry sensitive data, expired hypotheses, or a preference that belongs to one context into another task.

A wiki can connect hypothesis, evidence, decision, and consumers. It should not become an automatic tribunal that blocks legitimate change because an old page says otherwise.

And Git can show what changed, compare versions, and recover an earlier state. It does not prove that the new version is true. Version history is a trail; validation still needs a source, a test, and an accountable person.

That separation is what keeps a learning architecture from becoming a bureaucratic oracle. Each layer does something useful. None receives powers it does not have.

A small prompt to start without building a cathedral

You do not need to copy my entire system to try this. You should not: context, risk, and privacy are not as portable as an editor theme.

This prompt — instructions given to an AI system to guide a task — is a deliberately small start for an agent that works with files. It uses Markdown to keep notes readable and Git to record versions:

Help me create governed learning for this project using Markdown and Git.

When you identify a repetition, gap, contradiction, or a decision that is not
reaching the people or systems that need it, do not change rules, memory, wiki
pages, prompts, or automations on your own.

Instead:
1. record the signal and its origin;
2. formulate a hypothesis with supporting and contrary evidence and limits;
3. list potentially affected consumers;
4. propose the smallest reversible change;
5. ask for my confirmation, correction, or rejection before changing current sources;
6. after the decision, update only authorized files, linking the hypothesis and decision;
7. run proportional validation and explain how to undo the change.

Always distinguish memory, confirmed fact, hypothesis, decision, and current rule.
Do not store secrets, personal data, or conversations without a clear purpose.
Before editing, show the plan and what remains out of scope.

That does not create governance by itself. It opens a first gap: the agent stops treating learning as implicit permission to write.

Then the system matures as real consumers, real conflicts, and real costs of forgetting appear.

What can be automated — and what remains human

I want to automate detection of repetition, the search for affected consumers, contradiction checks, preparation of diffs — comparisons between versions that show exactly what changes — and validations that can be run.

I want the system to be insistent enough to say: “this looks like a decision without a source,” “this hypothesis was already rejected,” “this contract contradicts another,” or “you are about to spread one change across four places.”

I do not want to automate silent promotion of a hypothesis about my work, my writing, or a client operation.

That connects to the process in which I asked ChatGPT to prove what it thought it knew about me. A model can help find patterns and prepare better questions. The verdict still needs to return to the person who knows the consequences and is accountable for them.

At i-9.ai, this matters because an AI-assisted operation should not repeat errors faster merely because it gained memory and automation. It needs to learn enough to reduce rediscovery, without losing the ability to explain what changed, why, and how to go back.

A harness that learns well is not the one that changes the most files by itself.

It is the one that improves the next decision without erasing accountability for the last one.

Keep reading

• AI Forgot Exactly What I Had Already Decided
• A Hypothesis Does Not Become Fact Because AI Repeated It
• ChatGPT Already Knows a Lot About You. Before You Trust It, Make It Prove It

Go deeper

• Version control with Git: how to record changes, compare them, and recover earlier states.
• Markdown: the lightweight markup language used to keep documents readable without proprietary software.
• Provenance in W3C PROV: an introduction to recording the origin and transformation of information.

References and limits of use

• Pro Git supports only the explanation that version control records changes, compares states, and enables recovery. It does not confirm that a rule is correct, replace a backup — a safety copy made to allow recovery — or remove the need for human review.
• W3C PROV supports the general use of provenance as a trail of entities, activities, and responsible parties. The flow of hypothesis, consumers, confirmation, and rollback is an authorial engineering synthesis, not a complete implementation of that standard.

The cover image is a synthetic, text-free, language-independent editorial illustration of a signal that stops drifting when it meets confirmation and version history.