Running Cowork Lean

Every conversation with Claude runs inside a context window, a fixed budget of tokens that holds everything the model can see at once: its instructions, its tools, its memory, and the conversation itself. Manage that budget well and your AI agent is fast, sharp, and cheap. Manage it badly and you get one of two failure modes, and they pull in opposite directions.

Too little context and the agent is ignorant. It doesn't know your file conventions, your past decisions, your vocabulary. It asks questions it should already know the answers to, redoes work, and produces generic output. You end up paying in your own time what you saved in tokens.

Too much context and the agent is buried. Long conversations get slower and more expensive with every turn. Relevant facts drown in irrelevant ones: models attend less reliably to any single detail as the window fills. And when the window runs out, the system starts making lossy decisions on your behalf.

The craft is balancing on the edge of just enough. Here's what we've learned running a fleet of managed agents on Cowork every day.

We didn't learn this from documentation. We learned it building embedded AI staff, managed agents that live inside our clients' businesses and run all day, every day. When an agent runs continuously, context costs stop being an abstraction: every wasted token is paid on every turn of every session, across every seat, and the meter compounds. Our first agents carried everything into every conversation (every connector, every skill, long-running threads) because nothing forced us not to. Then we started measuring, and found that most of what our agents were "thinking about" on any given turn had nothing to do with the task in front of them. The overhead was ours, not the work's. Getting an agent to run lean turned out to be the difference between one that's economical to embed in a client's operation and one that quietly burns its margin on baggage.

What's in the window

Cowork gives you an exact accounting: type /context in any session and it breaks the window down by category. Here's a real reading from one of our sessions this week:

Two things jump out. First, the conversation itself, the thing you'd assume dominates, was only 12.5%. Second, the single biggest cost after free space was tool definitions for connectors we weren't even using in that session. Every connector you attach (GitHub, Gmail, Calendar, a browser, desktop control) ships a catalog of its tools into every session, whether or not that session ever touches them. Ours came to 85,000 tokens of standing overhead, more than the system prompt and built-in tools combined.

That's the general lesson: context cost is mostly fixed overhead you configured once and forgot, not the work you're doing right now.

The window is big, and that's a trap

Current Claude models offer context windows up to 1M tokens; the session we measured above was running a 500k window. Either way, the number sounds like abundance, and that's exactly the trap. A huge window invites you to never clean up: leave every connector attached, let threads run for days, pile on plugins. The session still works, so nothing forces the discipline.

But you pay three ways before you ever hit the wall. Cost: input tokens are billed (or metered against your plan) every single turn, so 100k of dead weight is charged dozens of times over a long session. Latency: bigger prompts process slower. Attention: the model's grip on any one instruction loosens as the haystack grows. A lean 150k session will reliably outperform a bloated 600k one on the same task.

What happens when it fills anyway

Cowork doesn't let a session slam into the wall mid-sentence. Notice the "autocompact buffer" in the table: 33k tokens held in reserve. As the window approaches full, the system automatically compacts the conversation: it summarizes the older transcript and replaces it with the summary. The session continues, but compaction is lossy by nature. The exact wording of an earlier decision, a number quoted in passing, the nuance of a correction: a summary keeps the gist and sheds the detail. If your agent seems to forget something from two hours ago, compaction is the usual suspect.

The practical rule: never let compaction happen to a session that matters. If a thread is getting heavy, end it deliberately, capture what mattered into a durable note, then start clean.

The levers

Not everything in the window is yours to control. The built-in system tools and the core behavior prompt are fixed. But four levers are, and they're ranked here by impact:

1. Connectors. The biggest lever by far. Every attached connector costs its tool catalog in every session, fleet-wide. In Cowork today, connectors toggle at the account level, not per project, so this is a real decision, not a per-thread tweak. Audit ruthlessly: for each connector, ask whether any current work needs it. In our reading, a calendar connector nobody had called in weeks was costing 8.6k tokens per session, every session, on every seat. The trade is honest: disconnect it and the capability is gone everywhere until you reattach, but most setups carry two or three connectors that fail the audit.

2. Thread hygiene. The conversation is the one category that grows on its own. /clear and /compact are Claude Code commands, built for the terminal, and they're not exposed in Cowork's chat interface: don't reach for them there. What Cowork gives you instead is /context to check how heavy a thread has gotten, plus the automatic compaction described above, which runs on the system's schedule rather than yours. The lever you actually hold is starting a new Cowork task per unrelated piece of work instead of living in one eternal thread. Old sessions aren't lost, pick the same one back up from any surface, but a fresh task means you stop paying for yesterday's baggage today.

3. Memory, the escape valve that makes lean possible. The reason you can afford short threads is memory. Cowork's memory system persists facts across sessions as small files, with a one-line-per-fact index loaded at start. In our reading, the entire memory system cost 3.2k tokens, versus the 62k transcript it substitutes for. That's the whole trick: durable knowledge belongs in memory, not in an ever-growing conversation. Tell your agent "remember this" when a decision or correction should outlive the thread. Prune the store periodically: merge duplicates, delete stale facts, so the index stays tight; there are skills purpose-built for consolidating memory. A memory file is written once and read cheaply forever; a transcript is re-billed every turn until the thread dies.

4. Instructions and skills. Your custom instructions, account preferences, project instructions, load into every session verbatim. Ours follow a rule worth stealing: stubs point, they never restate. The pasted instructions are a few lines identifying the agent and pointing at canonical documents in shared storage; the agent reads the heavy material only when it needs it. The same logic governs skills: every installed plugin adds its catalog entries to every session, so uninstall what you don't use. None of this is set-and-forget. We've spent hundreds of hours so far, and still spend several hours every week, tuning our agents to run on the knife edge of just-enough context: trimming instructions, pruning memory, auditing connectors, and re-measuring. That ongoing tuning is a real cost of running agents well, and it's exactly the work most people don't know their setup needs.

Just enough

An agent that knows nothing is cheap and useless, so minimal context was never the goal. The goal is that everything in the window is earning its place: instructions that point rather than restate, memory that holds facts at one line each, connectors that are still in use, and a conversation that's about the current task and nothing else.

Run /context on your own sessions this week. Our bet: your biggest cost will turn out to be the configuration you set up in month one and never looked at again, not the work itself. That's the thing about running lean. It isn't a setting. It's a habit of noticing.

Regards,

Charles Stack