I had already said the new articles would be published before the site’s new visual design, the redesign.

After a long conversation full of articles, images, code versions, validations, and changing priorities, I asked for the texts to be prepared for evaluation before publication.

In this project, that evaluation happens on a candidate version kept separate from the published site. Technically, it is presented as a Pull Request (PR): a proposed change that can be read, tested, and discussed before going live.

AI found a technically reasonable association: the files had been prepared in the structure expected by the redesign. So it put everything into the same evaluation as the redesign.

There was only one problem.

I had already decided otherwise.

TL;DR

Long AI conversations need to be compacted, summarized, or reconstructed to keep fitting into the available context. That is useful, but a summary must not become the source of truth for an operation. In this session, the technical relationship between the files and the redesign survived; the editorial precedence—publishing the articles first—did not. The answer isn’t simply to provide more text. It is to turn important decisions into durable state: contracts in AGENTS.md, a plan, a verification checklist, a candidate version, acceptance criteria, and an explicit execution order. Conversation is where we think. The system must know what it cannot forget.

“Forgot” is shorthand

I’m not saying the machine became distracted, tired, or lost a human memory.

A model receives a limited set of information to produce its next response. That space is called a context window: the amount of content that can participate in that execution.

When a conversation grows too large, the system has to manage the volume. It may select parts, retrieve records, or compact the history.

OpenAI’s official documentation on compaction describes a Responses API mechanism that reduces the volume of processed text—measured in units called tokens—while preserving information considered relevant for continuing long workflows.

The documentation itself uses the expression loss-aware compression: compression designed with possible loss in mind, not a promise to reproduce every sentence literally.

I’m not claiming the application used in this session executed that exact endpoint. The source supports the general mechanism and one official implementation. The concrete failure in this story is observable without that extrapolation: I gave a direction, it didn’t govern the later decision, and I had to correct it.

Compaction isn’t the problem

Without some form of compaction, a session like this would end much sooner.

I brought editorial direction, sources, visual identity, infrastructure, Cloudflare, comments, analytics, multilingual content, audio, SEO, new articles, and corrections to older ones.

That isn’t a prompt.

It’s an operation.

It would be naive to expect every sentence to keep the same weight forever inside a growing conversation.

Compaction lets the work continue. The problem begins when the system treats the compacted representation as if it were the canonical record of everything decided.

A summary is a map.

A good map helps us cross the territory. It still chooses what to show.

In this session, the map preserved that:

• three new articles existed;
• each had three language variants;
• the files had been created in a separate working version—the redesign branch;
• the user wanted the texts evaluated before publication.

But it weakened a more important relationship:

• the posts had to be published before the redesign and therefore could not depend on it.

The information didn’t disappear completely. It lost precedence.

In an operation, that is already enough to produce the wrong decision.

More context doesn’t replace governance

There is a temptation to solve every AI failure by pouring in even more context.

Sometimes that helps.

But context without hierarchy can also create a larger mass of facts, wishes, examples, corrections, and historical states competing for the next action.

The system needs to distinguish at least:

• an idea;
• a hypothesis;
• a decision;
• a superseded direction;
• a blocker;
• the required execution order;
• the file or service that holds current state.

That distinction does not emerge automatically from the amount of text.

It has to be modeled.

I can tell the same story ten times. If the system cannot tell that one sentence is a current decision and another is historical context, it gained volume, not direction.

Conversation is working memory

I like talking to AI through a microphone because I can externalize a line of reasoning without stopping to turn every perception into a document.

That fluidity is a major advantage.

But conversation works best as working memory: a transient space for elaborating, testing, correcting, and coordinating.

It should not be the only place where a decision lives if that decision changes which version of the project will be modified, when something will be published, security, price, scope, or responsibility.

When something becomes operationally important, it needs to change state.

It can become:

• a rule in AGENTS.md;
• an acceptance criterion in the evaluation process;
• an ordered task in a plan;
• a decision recorded in the repository;
• a structured field in a system;
• a verifiable human approval;
• an explicit link between the working version, the recorded change—the commit—and the environment where it will be tested or published.

It is the difference between saying something in a meeting and updating the contract that governs the work afterward.

In this system, AGENTS.md usually serves as that entry point. Before acting, the agent reads the file to understand the initial rules and learn how to navigate the rest of the project. It can point to the sources of truth, available tools, required workflows, mandatory validations, and situations in which a decision must return to a person. It is not magical memory. It is a readable contract that reduces improvisation and helps the agent find the right context.

The harness begins where chat ends

I use harness to describe the structure around the model that turns general capability into a directed operation.

The model is one part.

The harness includes instructions, tools, memory, permissions, reusable procedures—skills—specialized agents, validations, records, mandatory verification points, and approval paths.

A critical decision cannot depend only on “AI remembering.”

The harness needs a way to:

1. capture the decision;
2. identify that it is current;
3. connect it to the work it affects;
4. detect when an action contradicts it;
5. return the divergence to the author before executing.

In this session, one simple rule would have prevented the mistake:

The new posts will be published before the redesign. Their evaluation must start from main, the site’s primary version, and cannot depend on the new layout’s evaluation.

Once that rule exists in a durable place and is reread before the Git operation, it stops competing as just one more sentence in the history.

Memory without a source of truth isn’t enough

There is also a race to give agents “infinite memory.”

Memory helps, but accumulating records does not decide which one governs the present.

A system can perfectly remember five incompatible versions of one decision.

If it doesn’t know which one is current, it simply makes a well-documented mistake.

That is why I care about a source of truth: the place recognized as authoritative for a type of state.

In software development, version control records changes and links content to commits and branches. In a business process, the source of truth may be an ERP, CRM, contract, database, or formal approval.

The format changes. The question remains:

When two memories disagree, who decides which one counts?

The failure was also mine—as the system designer

It would be comfortable to write this article saying only that AI failed.

It did fail.

But I’m building precisely the kind of system that should support a conversation this large without requiring me to repeat every important decision.

If the direction was critical and remained only as an old statement, the harness still had a gap.

That does not transfer direction to the machine. Direction remains mine.

It means the system must make my direction executable and verifiable even when context changes, conversation is compacted, or another agent takes over a stage.

A good system does not require the user to behave like a machine to compensate for the machine’s transient memory.

It turns natural language into contracts at the right moment.

A simple protocol for long sessions

After this experience, I would reinforce seven practices:

1. Record material decisions. If it changes order, scope, publication, or responsibility, it leaves chat and enters durable state.
2. Mark replacements. A new decision must say which earlier direction no longer applies.
3. Keep a short current-state snapshot. Current version, candidate version, base, next steps, and blockers should fit into a quick read.
4. Reread contracts after compaction. The summary supports continuity; canonical files restore precision.
5. Validate topology before action. Before sending work for evaluation, confirm base, dependencies, and publication order.
6. Return contradictions to the author. If the likely action conflicts with a recorded decision, ask before executing.
7. Learn from the failure. Correct the delivery and the mechanism that allowed the divergence.

This matters for a blog.

It matters even more when an agent handles budgets, clients, inventory, contracts, infrastructure, or personal data.

This is how conversation becomes operation

At i-9.ai, the value isn’t delivering a chat window with a larger prompt.

It is turning requirements, decisions, exceptions, and responsibilities into a system that remains coherent after the meeting.

A client shouldn’t have to reteach AI how the company works every morning.

They also shouldn’t believe that voluminous memory replaces processes, permissions, and sources of truth.

The goal is to build an operational brain in the figurative sense: a structure that can receive human language, preserve direction, and coordinate execution without pretending consciousness or unrestricted autonomy.

That is exactly what this failure revealed.

AI doesn’t have to remember everything.

The system needs to know what it cannot forget.

And direction remains with the author.

If this sounds like a problem your company already has—decisions scattered across meetings, messages, and people’s heads—you can contact me.

Keep reading

• Writing with AI Didn’t Make Me Less of an Author
• If You Think AI Is Just a Chatbot
• Generic Agents Can Be Your Company’s Worst First Encounter with AI

Learn more

• Context compaction in the official OpenAI documentation: a mechanism for reducing a long conversation’s volume and continuing the workflow.
• Version control: an introduction to recording changes, versions, and recoverable states.
• Single source of truth: encyclopedic context on maintaining one authoritative source for each data element.

References and limits of use

• OpenAI, “Model guidance—Compaction”: describes Responses API compaction for long workflows and recommends monitoring context use. It does not document this specific session or prove which detail every compaction will preserve.

The description of the mistake, the lost priority, and the correction to the publication flow comes from this session. The relationship between working memory, sources of truth, and harnesses is an authorial engineering synthesis, not a controlled experiment on model behavior.

The cover is a synthetic editorial illustration about the difference between compacted context and a preserved decision.