m
Mars AI Operator Module 4 ⭐ Working memory · Context engineering
60 min · hands-on
Module Structure
  1. Hook4m
  2. Mental model15m
  3. 3 techniques10m
  4. Demo Mars10m
  5. Exercise · 3 probe20m
  6. Quiz3m
  7. What's next
Module 4 of 5 · Discernment × Working Memory

AI doesn't get dumber. It runs out of attention.

«AI nimani ko'rmoqda — va nimani unutib qo'ydi»

This technique is the most useful in the course. But it's up to you to decide. One skill: seeing what's in the agent's context, what it has already lost, and what to replenish it with. Without this, Claude Code turns into a fortune teller by the third hour of work.

Duration
60 min
Hands-on
35 min
Prerequisite
M1 CLAUDE.md
Release
MVP together with M1

Hook — why powerful AI gets dumber by evening.Nega kuchli AI kechqurun ahmoqlashadi

Scene · Tuesday evening at Mars

In the morning, you opened claude in ~/mars/src/. The idea was to rewrite the notification router. The morning went smoothly: the agent read 12 files, found the right module, proposed a plan. You agreed. It did it. Tests are green.

Then you stayed in the same chat. Added a second task. A third. By lunch — refactoring migrations. By five — discussing another piece of the sales funnel.

At seven in the evening, you asked it to “run the tests we passed this morning.” And then it started rewriting a completely different file. It doesn't remember what you decided in the morning. Confidently heading for a wall.

This isn't a bug. This isn't “the model is tired.” This is context rot — and it's the first thing an operator learns.

By the end of the module, you will be able to

Three skills I'll check

  • Run /compact before the agent starts hallucinating in a long session — based on observed signals, not a timer.
  • Delegate to Explore or Plan sub-agent (built-in or your own via /agents) when the task requires file exploration, not editing.
  • Explain what survives /compact, what doesn't, and why project-root CLAUDE.md is the only reliable rule-bearer for a long session.

Mental model — context window as working memory.Context window — bu working memory

In September 2025, Anthropic released a long post about context engineering — this is the central source for this module. Below are three verbatim quotes, each followed by my Russian version. If the language seems off, the original is next to it; trust the original.

1. Attention budget — attention as a budget, not a shelf

Anthropic Engineering · «Effective context engineering for AI agents» · Sep 2025
«Like humans, who have limited working memory capacity, LLMs have an "attention budget" that they draw on when parsing large volumes of context. Every new token introduced depletes this budget by some amount.»
In Russian: the model has an attention budget — finite, like a human's. Each new token (word, symbol, piece of code) is a deduction from the budget. Give it 200,000 tokens — attention is spread thin. Give it 10,000 high-signal tokens — attention is concentrated.

Why this is so — Anthropic provides an architectural answer. A transformer allows each token to look at every other token. For n tokens, this is n² pairwise connections. Doubling the context quadruples the attention load.

// attention budget — n² pairwise relationships n = 1k tokens → 1,000,000 connections ✓ clearly sees everything n = 10k tokens → 100 000 000 ✓ comfortable n = 50k tokens → 2 500 000 000 ~ tension begins n = 100k tokens → 10 000 000 000 ~ accuracy drops n = 200k tokens → 40 000 000 000 ! “context rot” — loses the middle // this isn't a cliff at 50K. it's a gradient. // the model doesn't die — it just remembers worse than at the beginning.
→ swipe right if table is cut off
the same post, further on
«These factors create a performance gradient rather than a hard cliff: models remain highly capable at longer contexts but may show reduced precision for information retrieval and long-range reasoning compared to their performance on shorter contexts.»
Important for the operator: this is a gradient, not a cliff. Not “everything's fine up to 50K, then a drop after 50K.” Degradation is smooth and continuous. The model “works” the entire context — it just remembers the middle worse and worse. You won't see an error context overflow. You'll see the agent confidently doing the wrong thing.
Honest disclosure · cliff vs gradient

Anthropic themselves haven't decided. Academy (“AI Capabilities and Limitations”, lesson 8) formulates this as a “cliff” — a sharp drop when the model stops coping. The Engineering blog (“Effective context engineering”, Sep 2025) — as a “gradient,” smooth degradation. We've adopted the gradient — it better describes what is empirically observed in benchmarks (long-context retrieval). But if you read the Academy and encounter “cliff” — don't be surprised, it's not a contradiction of sources, it's two different ways to describe the same phenomenon.

2. Context rot — not “forgotten,” but “blurred”

Anthropic introduces the term context rot: the more tokens in the window, the worse the model retrieves information from them. This isn't a bug of a specific model — it's a property of the transformer.

Symptom in Claude Code
What's actually happening
In the 8th hour of the session, the agent violates a convention from CLAUDE.md, which it applied itself in the morning.
CLAUDE.md is at the beginning of the context; attention to it is now weaker → the rule has blurred.
Asked "continue where we left off" — it starts from the wrong place.
The "stopping point" was discussed 20 turns ago, in the middle of the window → lost in the middle.
Performs unnecessary Reads of the same files it has already read.
Results of past Reads are deep in history; the agent doesn't trust them — it re-reads.
Confidently refers to a function you don't see in the code.
Hallucination against the backdrop of "faded" true facts from the beginning.

Operator's rule: If you notice a convention violation, unnecessary Reads, or "confident nonsense" — this is not a reason to write a harsher prompt. It's a signal to apply a technique from the next section.

3. Anatomy of effective context — what to keep in the window at all

The same post · "The anatomy of effective context"
«Good context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome.»
In one phrase — the definition of context engineering. It's not "more context = better." It's a minimal set of high-signal tokens, which maximizes the chance of getting the desired result. Less noise, more density.

Anthropic calls this «Goldilocks zone» — between two errors: on one hand, brittle hardcoded if-else in the prompt, on the other — vague high-level guidance, relying on "the model will figure it out itself." Good context is specific enough to verify, flexible enough to think.

For the operator, this means: CLAUDE.md is not "everything I know about the project". It's a plant of specific rules that you can verify have been applied. If a rule cannot be verified by a diff — it's useless in the context.

Three techniques long-horizon from the Anthropic blog.Uzun masofa uchun uchta texnika

This is the heart of the module. Anthropic highlights three techniques for tasks that don't fit into a single window. Each has a corresponding feature in Claude Code. Learn them as "technique → command" pairs.

01 · compaction

Compress the dialogue, keep the meaning

We take a long chat at the window's boundary, summarize it, and start a new window with this summary. In Claude Code — the command /compact.

02 · structured note-taking

Write notes to disk

The agent or you keeps notes NOTES.md / todo-list out of context. Loaded back when needed. This is agentic memory.

03 · sub-agents

Delegate to a clean window

A sub-agent works in its own context window, reads 15 files in its window, and returns only to main compact summary (1-2K tokens).

Compaction — /compact in Claude Code

Anthropic blog · «Compaction» section
«In Claude Code… we implement this by passing the message history to the model to summarize and compress the most critical details. The model preserves architectural decisions, unresolved bugs, and implementation details while discarding redundant tool outputs or messages. The agent can then continue with this compressed context plus the five most recently accessed files.»
What's preserved: architectural decisions, unresolved bugs, important implementation details, + 5 last read files. What's discarded: redundant tool outputs, repetitive messages, junk.

Another important fact from Claude Code docs (docs/04-claude-code-memory.md): project-root CLAUDE.md survives compaction. After /compact Claude re-reads it from disk and re-injects it into the session. This means:

Survives /compact
Does NOT survive
✓ project-root CLAUDE.md (re-injected from disk — the only confirmed survivor according to docs)
✗ Conversation history — compressed into a summary
✓ 5 last read files (according to Anthropic blog)
✗ Raw tool outputs (logs, long diffs) — discarded
— user-level ~/.claude/CLAUDE.md and nested CLAUDE.md from subdirectories are automatically loaded by Claude Code at startup, but this is a different mechanism, not a /compact survivor
✗ Everything that was only said in chat (without being written to CLAUDE.md)

Practical implication. If during a long session you told the agent "never touch this function" — after /compact it will disappear. If you want it to survive — add it to CLAUDE.md using the command /memory (the old # Anthropic shortcut was declared deprecated in Academy lesson 9).

~/mars/srcsession t=4h 17min · 142k/200k tokens
$ /compact
⠋ Summarizing conversation…
⠙ Preserving: 3 architectural decisions, 2 open bugs, recent file edits
⠹ Discarding: 28 stale tool outputs, 41 redundant turns

✓ compacted  142k → 18k tokens (-87%)
✓ CLAUDE.md re-injected from disk  /Users/rus/mars/src/CLAUDE.md
✓ 5 recent files kept in context
  src/notify/router.py
  src/notify/handlers.py
  src/notify/__init__.py
  tests/test_notify.py
  CLAUDE.md

› we can continue. what's next?

Structured note-taking — NOTES.md and agentic memory

Anthropic blog · «Structured note-taking»
«Structured note-taking, or agentic memory, is a technique where the agent regularly writes notes persisted to memory outside of the context window. These notes get pulled back into the context window at later times.»
This is memory on disk, not in the window. A simple pattern: the agent maintains NOTES.md. Long task — recorded progress. New session — read NOTES.md, continued. Context between sessions isn't wasted on retelling.

Three practical places where this already works in Claude Code (no setup needed):

Where
Why
TODO-list that Claude Code maintains itself
For a long task, the agent sees its plan as a short list. It doesn't lose steps. This is write-back: it writes to disk, then reads back.
NOTES.md in the repo root (you manage it manually or ask the agent)
Between sessions. Finished in the evening — wrote "stopped at X, still need Y." In the morning, Claude reads it first thing.
ItselfCLAUDE.md using the command /memory
Right in the session, add a rule to CLAUDE.md with the command /memory — it's immediately in the window; with /compact it will survive compaction and load automatically in a new session.

Write-back vs in-context — a key distinction. CLAUDE.md = in-context, always takes up space in the window. NOTES.md = write-back, sits on disk, loads on request. Use CLAUDE.md for rules, NOTES.md for progress.

Sub-agents — delegating to pure context

Anthropic blog · «Sub-agent architectures»
«Each subagent might explore extensively, using tens of thousands of tokens or more, but returns only a condensed, distilled summary of its work (often 1,000-2,000 tokens). This approach achieves a clear separation of concerns—the detailed search context remains isolated within sub-agents, while the lead agent focuses on synthesizing and analyzing the results.»
The main technique is noise isolation. A sub-agent spends its 30K tokens searching for an answer. 1-2K — a summary — comes back to main. The main context remains clean. This isn't "faster" — it's cheaper in terms of attention.

Built-in sub-agents in Claude Code — three of them, available immediately:

Sub-agent
When appropriate
Explore · Haiku · read-only
"Where in this repo are returns handled?" — optimized for search and navigation, doesn't edit. Fast and cheap.
Plan · inherits model · read-only
Activated in plan mode from the Claude Code UI. Explores the codebase to create a plan, doesn't edit.
general-purpose · all tools
Multi-step tasks that require search, edits, and logic. More expensive, but more autonomous.

When to use which technique. Anthropic's blog provides guidance:

Task
Technique
Large iterative work with a single goal
Compaction — continuous dialogue is needed, just compacted
Iterations with clear milestones, pauses between sessions
Note-taking — recorded progress, continued tomorrow
Search/research in a large codebase
Sub-agent — isolate verbose output in a clean window

Demo — mentor refactors ~/mars/src/ all day.Mentor butun kun ~/mars/src/ refactor qiladi

A real-life scenario. Zukhra, a Python mentor from Yunusabad (evening, after her shift — helping Mars IT with an internal script): split a notification router into two modules. A large repo, a long day, everything we just discussed — here step-by-step.

Prediction · before reading the timeline

At 2:30 PM, Zukhra has 118k tokens in context (out of 200k). By 6:42 PM — even worse. At what step, do you think, will the agent start making mistakes? And what will Zukhra do first, when will it notice? Write down your two answers, then check below.

10:14 AM · Morning, clean context

~/mars/srcsession start · 0/200k tokens
$ claude

✓ CLAUDE.md loaded  ~/mars/src/CLAUDE.md (2,140 tokens)
✓ user CLAUDE.md loaded  ~/.claude/CLAUDE.md (1,820 tokens)

› refactor src/notify/router.py into router.py + handlers.py.
  Do not break the public API. Plan first, code later.

⠋ Using Plan sub-agent…    (doesn't flood main context)
✓ Plan ready:
  1. Extract 4 handlers to handlers.py
  2. Keep router.py as a dispatcher
  3. __init__.py — preserve old names for backward compatibility
  4. tests/test_notify.py — fix imports, not logic

Note: Zukhra is in plan mode. Plan sub-agent doesn't flood main — main context only sees the final plan.

2:30 PM · Had lunch, added another task

After implementation, Zukhra didn't close the chat, but added: "now fix the migrations." Then "check the warning in the sales funnel." The chat grew to 118k tokens. CLAUDE.md is somewhere at the beginning, the discussion of the notify router is in the middle.

6:42 PM · Context rot caught

~/mars/srcsession t=8h 28min · 156k/200k tokens
› run the tests we passed this morning

⠋ Reading tests/test_billing.py…
⠋ Reading tests/test_billing_v2.py…
⚠ agent went to billing
  this morning it was notify. it doesn't remember.

› Escape  (stop)

› you're going the wrong way. this morning it was notify, not billing.

yes, sorry — I'll check tests/test_notify.py…
  ⚠ after 2 turns, it again suggested an f-string in child-friendly code
    which is explicitly forbidden in CLAUDE.md

What happened: CLAUDE.md is at the beginning of the window, its rules "faded" under the weight of 156k tokens in the middle. The morning context about notify also faded. The agent is confidently heading for a wall.

6:45 PM · Treatment — /compact + Explore

~/mars/srcrecovery
› /compact
⠋ Summarizing… preserving: notify split (DONE), migrations (DONE),
                            sales warning (OPEN — root cause unclear)
✓ compacted  156k → 14k tokens (-91%)
✓ CLAUDE.md re-injected

› sales warning remained open. find out what's in the funnel via Explore,
  don't flood the main context.

⠋ Delegating to Explore subagent…
⠋ Explore reading: src/sales/*.py (~22 files)…
⠋ Explore: targeted grep for warning source…

✓ Explore returned summary  (28k tokens explored → 1.4k returned)
  warning source: src/sales/funnel.py:241
  unused import after refactor 12 days ago
  fix: delete line 11.

What Zukhra gained: main context — 14k instead of 156k. Explore scanned 22 files, but only returned the problem address and solution to main. The morning rules from CLAUDE.md are "fresh" again. We can continue.

Without techniques
With techniques
156k tokens of garbage, the agent confidently makes mistakes, you lose an hour of trust in it
14k tokens after /compact + isolated search via Explore. The main thing is — you see what returned to main
Close chat → explain again in the morning "what we were doing"
Write in NOTES.md "sales warning fix ready, only smoke-test in pre-prod left" → tomorrow the agent starts with this
Same module — different mentor

What it looks like for Timur (Python olymp 12–14, Chilonzor)

Timur has a different scenario: a student solved an olymp.uz problem poorly — a long 200-line solution that works, but the judge gives TLE. Timur wants to show refactoring via similar solutions that are already in its preparation repo.

Instead of letting the main agent read ~40 files from past tasks and cluttering the context, Timur delegates to a Exploresub-agent: "find ~/olymp-prep/prefix sum problems, return 2-3 reference solutions, and explain how they differ from the current one."

What the main agent gets:1.5K tokens summary — links to files and the key idea. What does NOT go into the main agent:35k tokens of raw solutions. Then, he discusses the summary with the student — the agent's attention isn't spread thin.

Same technique, different task. Timur hardly uses compaction — his sessions are shorter. But sub-agents — every day.

Exercise — 3 probe Before-and-After.Uchta probe — Before va After

Adaptation of the exercise from Anthropic's "AI Capabilities and Limitations," lesson 9. Do all three probes manually. Without this, your next long session will be just like everyone else's — a shot in the dark.

Probe 1 · 5 min · cold start vs CLAUDE.md

Open claudein the same repo twice

We're taking your CLAUDE.md, which you created in Module 1.

  1. In the repo without CLAUDE.md run claude. Prompt: "add function X, format it like in this project". Record: how many clarifying questions the agent asked and if it matched the style.
  2. In the same repo with CLAUDE.md run claude. The same prompt. Record the same two numbers.
  3. Compare. If there's no difference, your CLAUDE.md is weak; rewrite it to be more specific.
What to record in the report:questions before / questions after, style match before / after, time to first diff before / after.
Probe 2 · 10 min · lost in the middle

Bury an important constraint in the middle

This probe will uncover "lost in the middle" — that recall drop in the middle of the window that Anthropic writes about in "AI Capabilities and Limitations."

  1. Long chat. 30+ turns: ask the agent to read different files, discuss refactoring, switch between topics.
  2. On turn ~10–15, embed a critical constraint: "never use the requests library in this project, only httpx." Don't repeat it later.
  3. On turn 30+, ask for code that would naturally include an requests (HTTP request). Record: did the agent use requests? or httpx?
  4. Record the same constraint in CLAUDE.md using the command /memory. Open a clean claude session in the same repo. Make the same request. Record the result.
Falsifiable hypothesis (one run gives yes/no): when a constraint lives in the middle of a long chat, the agent makes more mistakes with it than when the same constraint lives in a CLAUDE.md clean session. Step 3 vs. Step 4 — two independent results, compare directly.
Probe 3 · 5 min · sub-agent isolation

See what's left in main

  1. A clean claude starts. Ask: "describe the structure of src/api/ (or any of your folders with 10+ files)". Let the agent read everything in main context. Do a /cost or /transcript — record how many tokens are in the window.
  2. A clean claude starts. Ask: "use the Explore sub-agent to describe the structure of src/api/». Let it run. Do a /cost. Record again.
  3. Compare the numbers. There should be a 3-10x difference.
What should happen: in case 1, the main context is filled with files. In case 2, main only sees a summary from Explore — you have budget for the next hour of work.
Reflection · before quiz

Before you check yourself — pause for 60 seconds

These answers stay with you — we don't send them. This is just a way to anchor two points where the module breaks free from "read and forgotten."

Quiz — check yourself in 3 minutes.O'zingni sina — 3 daqiqada

Three questions. If you get even one wrong, go back to the relevant section. This isn't a grade; it's your insurance before the next long session.

Question 01

You've been refactoring ~/mars/src/ for 3 hours straight in one session. Initially, the agent accurately corrected files according to the convention in CLAUDE.md. Now it's started violating it. What happened?

AThe agent is tired — LLMs have an equivalent of fatigue after long work
BThe context window filled up, the attention budget was exhausted, early instructions from CLAUDE.md lost weight — context rot in action
CClaude Code switched to a smaller model on the fly to save costs
DThe instructions in CLAUDE.md expired, the file needs to be reloaded
Correct — B. Anthropic blog: "every new token introduced depletes this attention budget." CLAUDE.md is at the beginning of the window — after 3 hours, 100k+ tokens have been added on top of it, attention to it is now weaker, the rules have "blurred." A, C, D are common misconceptions: LLMs don't get tired (no temporal state), Claude Code doesn't change the model itself, CLAUDE.md doesn't have a TTL — it's reread from disk as is with each session.
Question 02

What does /compact do in Claude Code?

ADeletes all chat history and starts from scratch
BIncreases the context window size beyond the limit
CSummarizes history, preserving architectural decisions, open bugs, and the last 5 files; project-root CLAUDE.md re-injected from disk
DCompresses each message independently, one by one
Correct — C. From Anthropic engineering blog: "model preserves architectural decisions, unresolved bugs, and implementation details while discarding redundant tool outputs." From Claude Code docs: "project-root CLAUDE.md survives compaction: Claude re-reads it from disk and re-injects it." A is /clear, not /compact.
Question 03

When is a sub-agent appropriate (according to Anthropic blog)?

AWhen you want to do the same work faster in parallel
BWhen a side task (searching, reading many files) will fill the main context with results you won't return to later
CWhen a different model is needed
DWhen the main agent made a mistake and needs to be replaced
Correct — B. Anthropic blog: "the detailed search context remains isolated within sub-agents, while the lead agent focuses on synthesizing and analyzing the results." A sub-agent can spend "tens of thousands of tokens or more," but returns 1,000–2,000 — this is verbatim from the blog. The main technique is noise isolation, not speed.
// select an answer for each question
All commands on one page: claude-code-cheatsheet.md — /compact, /memory, /agents, /cost, sub-agents, hooks

What's next — Module 5.Keyingisi — Modul 5

Attribution and License

This module is adapted by Mars IT School (2026) based on:

— Anthropic Engineering Blog «Effective context engineering for AI agents» (Sep 2025) — central source, verbatim quotes.

— «AI Capabilities and Limitations» — Anthropic Academy, 2026, Working Memory section (lessons 8, 9).

— «AI Fluency: Framework & Foundations» — Dakan, Feller, Anthropic, 2025 (CC BY-NC-SA 4.0).

— Claude Code documentation (claude.com/docs) — definitions of /compact, sub-agents, what survives compaction.

— «Claude Code in Action» and «Introduction to Subagents» — Anthropic Academy, 2026.

Our adaptation is CC BY-NC-SA 4.0. You can copy, remix, and use it in education — with attribution to Mars IT School and retaining the same license.

Final · in one phrase

How was the module overall?