Sep 6, 2026 8 min read

The MyClaw Playbook: Maximize Every Token

Hello, MyClaw users,

We have been noticing a recurring pattern among MyClaw users: agents can burn through far more tokens than people expect, even when the task itself does not look particularly complicated.

The problem usually is not that the agent is “thinking too much.” It is everything accumulating around the task: long-running Sessions, files that no longer matter, verbose tool output, oversized logs, unused MCP tools, repeated repository searches, and context that keeps getting carried forward long after it has stopped being useful.

This matters even more for MyClaw because both Hermes Agent and OpenClaw are designed to run beyond a single short coding session. They can maintain memory, use tools, spawn subagents, and keep work going across much longer periods. That persistence is useful, but it also makes context hygiene much more important.

So we went through the main places where tokens get wasted in real agent workflows, and how to keep Hermes and OpenClaw Sessions lean without making them less capable.

The basic idea is simple: The biggest waste is usually not how many tokens the agent uses. It is how many useless tokens it keeps carrying.

TL;DR

If you do not want to read the whole thing, remember these:

Keep unrelated tasks out of the same working context.
Choose your model and reasoning level before a long task when possible.
If you already know the relevant file or path, point the agent directly to it instead of making it search.
Keep test, build, and log output quiet. Large tool results stay in context and make later turns heavier.
Check /context occasionally. Tools, MCP servers, skills, memory, and workspace instructions may already occupy a lot of context before the task starts.
Compress long Sessions when earlier details are no longer useful.
Use isolated subagents for high-noise work such as log analysis, repository scans, and long research.
Put durable information into memory instead of keeping a Session alive forever.

The main idea is simple: Do not optimize for fewer tokens. Optimize for less useless context.

Maximizing Token Value

With traditional editors, workflow messiness did not cost much. You could open ten irrelevant files, run a full test suite, or keep thousands of terminal lines around without thinking about it.

Agentic tools are different. Suppose you ask an agent to fix one failing test.

In one Session, you give it the exact test file and implementation. It reads both, edits the code, runs the relevant test, and finishes.

In another, you only say: the tests are failing. Fix them.

The agent may search the repository, read several unrelated files, run a larger test suite, inspect logs, and then eventually find the same bug.

Unnecessary exploration becomes context that later turns may continue carrying.

The final result may be identical. The amount of context generated along the way is not. Once files, command output, and tool results enter the working context, they can continue affecting later turns.

So token efficiency is not simply about using fewer tokens. It is about making sure the tokens entering the Session are useful.

What Determines the Cost?

Three things matter most: the model, input and output, and prompt caching.

The Model

Larger and more capable models generally cost more. That does not mean you should always use the cheapest one. It means the model should match the task.

Complex debugging, architecture decisions, ambiguous planning, or difficult reasoning may justify a stronger model. Repetitive tasks such as renaming variables, checking paths, running tests, searching for known strings, or making mechanical edits usually do not need maximum reasoning.

The same applies to reasoning level. Hermes exposes reasoning controls, while OpenClaw also supports model-dependent thinking controls. If the task is simple, there is little reason to keep reasoning at the highest level.

The image shows why stronger models and higher reasoning effort are not automatically better for every task.

Input and Output

An agent request is not just your latest message.

Before every model response or tool decision, the model may also receive:

soul
memory
agent rules
tool definitions
skills
conversation history
files
terminal output
previous tool calls and results

Imagine a simple task that needs several tool calls. The process is closer to:

context → think → tool
larger context → think → tool
larger context → think → tool
larger context → answer

Each tool result can enlarge the next request.

*Each new tool result can still make the next model call larger.*

That is why a Session can become expensive even when your own prompts remain short.

Prompt Cache

Prompt caching reduces some of this cost. If the beginning of a new request matches content the provider recently processed, parts of the previous context may be reused rather than recomputed from scratch.

What matters is the general principle: stable context is easier to cache than constantly changing context.

This is why repeatedly switching model, provider, or authentication path inside a long Session can be inefficient. Hermes tries to reuse provider-side prompt caching where available, while OpenClaw also includes cache-aware session behavior and keeps stable parts of the prompt separate from more volatile information.

So if you already know which model you want for a task, choose it early. Do not model-hop every few turns unless there is a reason.

Keep Sessions Focused

This is where Hermes and OpenClaw begin to differ.

Hermes

Hermes has persistent memory outside the current Session. That means you do not need to keep one conversation alive forever just because something may matter tomorrow.

If the task changes completely, start a fresh Session. If the same task continues but the earlier process is no longer useful, compress it. Information that should survive future Sessions belongs in memory.

A useful mental model is:

Session = current working context
Memory = information worth keeping

Do not use a giant Session as a substitute for memory.

OpenClaw

OpenClaw is more oriented toward a persistent main agent. Its main Session may intentionally carry continuity across conversations and channels, so aggressively resetting it for every tiny topic is not always necessary.

Instead, isolate the noisy work. Large coding jobs, long research, repository scans, large logs, and background tasks can go into separate Sessions or subagents.

So the OpenClaw version of the rule is slightly different: Keep normal continuity in the main Session. Isolate expensive work.

For Hermes, this advice maps fairly directly to starting fresh or compressing when the goal changes. For OpenClaw, the better adaptation is to preserve useful main-session continuity while isolating high-noise work.

When Should You Compress?

Long Sessions eventually accumulate information that was useful earlier but is no longer useful now. That is when compression helps.

Hermes provides /compress, while OpenClaw has compaction and context-pruning mechanisms.

The right time to compress is when the task is still continuing, but you no longer need the full path that got you there. For example, maybe you spent 30 turns exploring a codebase and have now settled on an architecture.

You probably do not need every failed hypothesis and search result anymore. What matters now is the architecture, the decision, the constraints, and the next step.

Compress the rest, but do not do it mechanically. If the Session is already small, there is little benefit. Compression works by removing detail, which also means it can remove detail you later wish you still had.

Subagents

Subagents are another way to keep the main context clean. They are especially useful when the intermediate work is much larger than the final answer.

For example:

Analyze this 7,000-line log and return only the error cause and relevant line numbers.

The subagent can read the entire log, search through it, and reason over it. The main agent only receives the result.

Hermes subagents operate with their own context, so large intermediate files and tool output do not have to stay in the parent Session. OpenClaw also supports isolated subagents, which are useful for the same reason.

*The main Session receive only the useful result while noisy intermediate work stays inside a separate agent context.*

Good subagent tasks include large log analysis, long research, repository exploration, scanning many files, and other noisy tool-heavy work. But not every task needs one. If the task is tiny, the subagent may simply reread information the parent already knows and create more work.

The rule is simple: use a subagent when the intermediate context is much larger than the result you need back.

Persistent Memory Is Not a Bigger Session

Hermes and OpenClaw both support persistent agent behavior, which raises another question: what should actually survive?

Good persistent information includes stable user preferences, long-term project constraints, recurring workflows, important decisions, and environment details that remain useful.

Bad persistent information includes temporary logs, today's stack trace, failed experiments, giant copied documents, and information that mattered for one task only.

If temporary information goes into persistent memory, you have simply moved the context problem somewhere harder to clean.

Memory should hold durable knowledge. Session context should hold current work.

The Four Things to Check First

Most wasted context comes down to four things:

The Session is too long. Old information keeps travelling with the current task even though it no longer helps.
Too much unnecessary information entered the context. Large logs, unrelated files, noisy terminal output, unused MCP servers, oversized skills, and unnecessary tool schemas all add weight.
The model or reasoning level is larger than the task requires. Use stronger models when the work deserves them, not by default.
Working context is being used as permanent storage. Hermes and OpenClaw both have mechanisms for information that needs to survive. Let temporary context stay temporary.

*Oversized Sessions, noisy context, overpowered models, and inefficient cache behavior remain the biggest places to look first.*

One Session should contain one task and only the context needed to complete it.

And the general rule for both is even simpler: The biggest waste is rarely too few tokens. It is too much useless contex.

Meet MyClaw

Maximizing every token is only half the job. You still need to keep the agent itself running.

That is what MyClaw is built for.

Instead of managing servers, dependencies, model APIs, credentials, and uptime yourself, MyClaw gives you a ready-to-run environment for OpenClaw, Hermes Agent, and multiple leading AI models.

The goal is simple: spend less time maintaining the agent, and more time making it useful.

One-click setup. 24/7 uptime. Zero DevOps. And that's where the real agent revolution begins.

MyClaw is a best-in-class AI agent platform that brings together OpenClaw, Hermes Agent, and production-grade infrastructure to help businesses launch intelligent agents that understand goals, use tools, automate workflows, and deliver finished results.

MyClaw already hosts OpenClaw and Hermes, connecting models from every major AI provider, including the latest text, reasoning, and image generation models from OpenAI, Anthropic, DeepSeek, Kimi, GLM, Google Gemini, and more through MyClaw's model gateway.

No lock-in. No juggling API keys. No switching between platforms. Pick the best model for the job, give your agent the tools it needs, and let it run.

Run Best-in-Class AI Agents on MyClaw.ai — In Seconds, Always On 👇