Stop briefing the AI every Monday morning
If your agentic workflow needs a re-brief at session start, you’ve built a chat tool with extra steps
Why most agentic workflows fail at the session boundary, not the prompt
Context windows are RAM, not storage, and treating them otherwise quietly breaks everything
The fix is structural: stateless processor, durable file-based memory, session-start protocol
What this looks like in pre-production, and why producers are the right people to build it
Monday morning. I sit down. I open an agentic harness, like Codex or Claude Code. Before any actual work happens, I type a paragraph that goes something like “so where we are is, we resolved the weapon spec last week but the environment LODs are still open, the client hasn’t replied about the priority on...” and so on, for roughly two hundred words, before I can ask the first useful question of the week.
That paragraph is a tax. It shouldn’t exist. The fact that I’ve quietly accepted paying it, and that most people I talk to building agentic workflows have also quietly accepted paying it, tells you something about how the field is designing these things.
The Monday brief is the symptom. The diagnosis is that we are building agentic workflows as if the AI is a colleague who went home for the weekend and forgot a bit. It isn’t. It went home and was destroyed. The thing on Monday morning has never existed before.
Context windows are RAM
The conceptual error is treating the context window as storage. It looks like storage from the inside. You scroll up and the conversation is still there. You add to it and it gets longer. So when an agentic workflow starts to misbehave, the instinct is to feed it more: a larger model, a fuller history, a more careful prompt.
The mem0.ai team wrote about this and the framing is the cleanest I’ve seen. The context window shares properties with RAM that distinguish it from persistent storage and make it unsuitable as a long-term data store. It is volatile, and everything in it disappears when the session ends, including preferences stated at turn 1, constraints set at turn 3, and decisions made at turn 7. Beam.ai has written about the same idea. The most common failure in production is an agent that remembers nothing between sessions. The context window resets. Every preference, every learned behaviour, every correction the user made in the last conversation is gone.
This is not a niche failure. Gartner found that 61% of organisations had begun their foray into agentic AI development, and predicts that 40% of agentic AI deployments will be cancelled by 2027 due to rising costs, unclear value, or poor risk controls. Other research is bleaker. Carnegie Mellon’s TheAgentCompany benchmark tested ten leading AI agent models across 175 real-world tasks. The best performer completed just 30.3% of tasks. RAND concluded that more than 80% of AI projects fail, twice the rate of non-AI IT projects. S&P Global found that 42% of companies abandoned most of their AI initiatives, up from 17% the prior year.
A lot of factors drive these numbers. State management is one of the load-bearing ones, and it’s the one producers run into first because we live by continuity. A producer who can’t remember what happened last week is not a producer. So when our tooling has no memory between sessions, we patch it ourselves. We type the brief. We re-explain. We feel productive because the response on Tuesday looks coherent.
A larger context window delays the problem. It does not fix it.
The fixes that the wider conversation gravitates to all address the symptom. Bigger windows. Better summaries. Compaction. Hybrid memory schemes. They share an assumption: that the right place for state is inside the model’s working memory, and the work is to keep that memory healthy. This is the same idea as managing a goldfish’s working life by getting it a bigger bowl. The goldfish still forgets the bowl every twelve seconds.
Worse, summary-based fixes degrade actively. Summaries summarise summaries. The history gets blurrier and the agent starts answering with confidence based on a compressed version of a compressed version of what you said three sessions ago. The brief gets longer, not shorter, because you’re now also correcting the agent’s distorted model of where things stand.
The Monday brief is your workflow telling you it doesn’t have a place to keep things.
State lives in files
The fix is structural. Stop trying to make the AI remember. Build a system where it doesn’t have to.
State lives in files. The AI is a stateless processor that reads from and writes to a shared file system. Memory is durable, external, and human-readable. Every open question, every assumption, every decision lives in a structured file with an ID, an owner, and a timestamp. Nothing lives only in chat. When a question gets raised during a design session, it gets written to the tracker immediately. When a decision gets made, it gets written to the decision log with rationale.
At the start of every session, the AI reads the files. That’s the briefing. Not me typing two hundred words on a Monday morning. The system already knows where things are because the files already know where things are. The AI just reads them.
Context window resets become a non-event.
This is the move that breaks the whole class of problem. Every horror story about agentic AI losing context, dropping decisions, or contradicting itself across sessions, almost all of it dissolves the moment state stops living in conversation history.
The mechanics are straightforward. You need a small set of structured files: an open questions tracker, a decision log, an assumptions ledger, an inbox for things that come in between sessions. Each entry has a stable ID. Each ID links to context. The AI’s first action in any session is to read these and report what is unresolved, what is blocked, and what needs a call. The AI’s last action is to update them.
A developer would recognise this as a database with no DBMS. It is. The thing that makes it work for a producer rather than a developer is that the files are human-readable. I can open a markdown file at 11pm and see exactly what’s open. No query. No tooling. The files are the system of record and they’re also the briefing document and they’re also the audit trail.
The session-start protocol is the second half of the move. The AI doesn’t decide to read the files because I asked nicely. It reads them because that’s the first thing it does, defined in a skill or a CLAUDE.md or whatever your tooling calls it. The skill says: at session start, read these files, summarise their current state, flag anything blocking, surface anything that needs a decision today. Then we work.
What this gives you is something that survives context window resets, model upgrades, app crashes, and the gap between Friday night and Monday morning. The state is in the files. The AI reads them fresh. There is no Monday brief because there is nothing to brief about.
The asymmetric collaboration
Where this lands in pre-production is worth dwelling on, because pre-production is where the cost of bad state management is highest and where the win is biggest.
Pre-production generates a specific kind of cognitive debt. Open questions that nobody answered. Assumptions that hardened into facts before anyone checked them. Decisions that were made in a Slack thread and never written down. By the time you hit production, that debt is invisible and expensive. Most projects take 25-30% longer than expected. A chunk of that overrun is debt being paid down by people who don’t know they’re paying it.
A human producer can track a sprint’s worth of this. Not a full pre-production cycle. The volume defeats us. The cross-domain spread defeats us. The lag between when a question is raised and when it gets resolved defeats us. So we drop things. Not because we’re bad at the job, but because the job at full volume is bigger than what one head can hold.
This is where the agentic system earns its place. The AI tracks everything. It captures questions as they surface. It assigns IDs and links them to the relevant spec area. It flags when an unresolved assumption is blocking other work. It routes questions to the right specialist for a draft answer. It updates status when something resolves. None of this needs my judgement. All of it needs to happen.
The human decides everything. Scope calls. Risk acceptance. Trade-offs between competing answers to the same open question. Anything that touches shared systems or external stakeholders. The decisions get made by the person whose job it is to make them. The bookkeeping gets done by the thing whose job it is to do bookkeeping.
The AI handles the volume. The human handles the judgement.
This split is the actual wedge for producers in agentic work. Most of the conversation about AI in production is framed as the AI doing the producer’s job. That framing is wrong twice. It overestimates what the AI can decide, and it underestimates what the producer’s job actually is. A producer’s job is the queue of open questions, the integrity of the decision log, the visibility of dependencies, and the deliberate spending of a small attention budget on the right calls. The AI can absorb the first three. It can’t do the fourth. So the producer does more of the fourth. Better.
The skill of being a producer transfers cleanly into the skill of running an agentic workflow because the discipline of tracking is the discipline we already practise. We were already trying to do this manually and failing because the volume was too high. The AI makes the volume tractable. We get an instrument that lets us play the craft we already know.
The AI in this system doesn’t make product decisions. Its job is to make sure nothing falls through the cracks and that the human has everything they need to make good calls fast. The value is in the tracking fidelity and the structured surfacing of what’s open. The AI has no opinion about what to build. Its opinion is about what’s been left undecided. Those are different things.
Pre-production is full of irreversible decisions made under uncertainty. The system doesn’t reduce the uncertainty. It makes sure the decisions get made deliberately, with full visibility into what is open and what depends on what, rather than quietly becoming assumptions that nobody remembers making.
If you sit down on Monday and have to tell the AI where you left off, you haven’t built an agentic workflow. You’ve built a chat tool with extra steps.
The Monday re-brief is the hidden tax nobody budgets for. Half my first session each week is just pasting last week’s context until the AI is useful again. The fix isn’t a sharper prompt, it’s the thing actually remembering what we already settled. How are you keeping the assumptions from going stale?
The shift in 'stop briefing the AI every Monday morning' is treating context as a product asset, not a meeting ritual. The production version needs durable state: decisions, open risks, source links, ownership, and what changed since the last run. Otherwise the agent is just being re-onboarded with a longer prompt.