If you do it sequentially you only read those files approximately once, and everything hits the same prefix cache

This is why the subscription plans are forced through the harness (the "OpenClaw Wars"): it creates a false equivalence in the minds of many customers between API tokens (latency sensitive, easy to measure) and Claude Code tokens (remnant backfill to stay to the right of the roofline, marginal cost often zero).

Selling sausage as sirloin is a great business if people go for it. And there's nothing inherently wrong with spot pricing, as long as you're honest about it...

If you plan on continuing on in the parent, and aren't going to necessarily be touching the systems the other agents are exploring, it can be worth it.

It's useful in certain situations where the parent context may need the "10,000 foot" view of something without going back in there. But subsystem-specific AGENTS.md/CLAUDE.md files are still superior and accomplish the same thing. The problem with those is they can become stale.

Yesterday, I wanted to review a complex piece after a large refactoring, and requested a review plan beforehand. The first step was 8 agents + one more to verify the findings (all Fable). Looks good, approved.

The verification step turned into an attempt to throw a party with 41 Fable verifiers.

It will find a way.

That said, if your project is "do this well-planned thing on a bunch of things in parallel" then you should absolutely be instructing to have subagents "step down" to less curious models. Their output may well be more cohesive as a result!

Probably because the general purpose subagents inherit the parent model.

I tell Claude explicitly to use Explore subagents, which use Haiku only, now.

  "permissions": {
    "deny": [
      "Task(Explore)"
    ]
  }

I read that this is because it wastes time looking through past conversations and other context to figure one what you might want it to do - a less ambiguous prompt would be better.

I appreciate that Codex is open source and OpenAI has explicitly said using the subscription with other agents is ok. OpenAI has been much more consumer-friendly recently.

That'll be $50 — please.

im on local only AI and subagents are only valuable when they avoid polluting the context with extraneous file reads and parallel exploration when fixes are linear.

as OP is on about, subagents burn tokens because they arnt a deterministic intelligent gatherer but like pooluring water into a maze hoping the exit will illuminate.

only if you don't specify which model should be used

When using Pi, one way to significantly reduce input tokens it yields is to ignore common bookkeeping "dot directories", such as `.git`. How to do so can be found with the following interactive Pi prompt:

  How do I configure Pi to ignore git related artifacts, such 
  as the project's .git directory?

I haven't tested it on anything bigger but it doesn't seem to do the kind of proactive testing, that they do in bigger harnesses.

Codex at least has a system prompt that tells it not to consider a feature a complete until it has verified it. I'm not sure about Claude Code.

I suppose I could add that one line to the prompt, and it would get me much closer to agi :) I think Fable does this proactively even without a prompt, but I haven't tested that yet.

If Fable in my own harness is significantly cheaper than Claude Code, that would be very appealing. (I could actually afford to use it for most things!) But I think most of the cost comes from the testing it does. So we'll have to see.

[0] https://minimal-agent.com/

If you don't use a subscription, and pay per token instead, you can easily move to another harness.

Ultimately this combo worked:

1. https://pi.dev/packages/pi-tool-guard —- corrects key name synonyms and common structure errors, so tool calls succeed automatically (e.g if the model hallucinates old_str instead of oldText). It also wraps top level oldText/newText in an edits array if the tool didn’t do it.

2. https://pi.dev/packages/@aboutlo/pi-smart-edit - white-space-tolerant edits, as Qwen would sometimes add a fifth space to a four space indent

Hashline edit tools didn’t work well for me at all, they confused the model and it still failed to edit correctly. Also line removals would invalidate the rest of the file requiring re-reads. I tried pi-hashline-edit-pro, though I see it now keeps a database of hashes to help keep them stable across edits. Regardless Qwen kept thinking that the hashline prefixes were part of the source.

> When context gets too long, maki compacts history automatically: strips images, thinking blocks, and summarizes older turns.

Don’t the summaries of older turns effectively invalidate the context cache, such that you consume less tokens but more expensive tokens?

> CRITICAL: Do NOT spawn sub-agents for any reason. Perform all work in the main session. If a task is too large, ask me to break it down manually.

> This is a big task, and can easily get too large. However, sub-agents make the situation worse, and eat through our token budget way too fast. Do not use them.

> Take on manageable tasks. Don't try to do everything at once. When you start on a big task, break it down into smaller tasks, and make sure you finish each task before starting on the next one.

Or actually Claude put it there for me. Maybe it's a bit much, but it seems to work.

Unless they are orthogonal they most likely require similar context anyway so multiple sub agent is just wasteful.

   Opus 4.8 (1M context)
   claude-opus-4-8[1m]
   23k/1m tokens (2%) 

   Estimated usage by category
   System prompt: 3.9k tokens (0.4%)
   System tools: 13.9k tokens (1.4%)
   Custom agents: 235 tokens (0.0%)
   Memory files: 28 tokens (0.0%)
   Skills: 4.9k tokens (0.5%)
   Messages: 8 tokens (0.0%)
   Compact buffer: 3k tokens (0.3%)
   Free space: 974k (97.4%)

Or are you saying my sub agents burned so many tokens because they were all using Fable, whereas my main agent could do the same job with a lesser model?

"Agent(Explore)"

Using VS code if it matters.

https://code.claude.com/docs/en/changelog#2-1-198

> The built-in Explore agent now inherits the main session’s model (capped at opus) instead of running on haiku

Doesn't the model need at least a basic system prompt to understand what tools are available?

Therefore, you should include the actual costs associated with the task in API token usage or subscription level. Is there a reasonable way to do apples to apples cost comparison?

Qwen 3.6 35B A3B and Qwen 3.6 27B can both do reliable tool calls on Pi at Q4_K_M using llama.cpp

I guess the cache would only be invalid if the day changed or the root directory, which would technically happen infrequently enough.

I mean, that's a very weak argument? Isn't a much more plausible explanation that with your tooling you'll have more of a lock-in than with just your model?

OTOH, this makes typical subscriptions usages consume more tokens, which are included in their flat fee.

This sounds more like incompetence than malice.

Competition is good.

Edit: consumer Claude subs are the 5%. I’d bet most all of CC subs lump in under enterprise.

  - API & Enterprise: 75% to 85% of total revenue.
  - Business Subscriptions: Roughly 10% to 15%.
  - Individual Subscriptions: About 5%.

That would depend entirely on what your device is. This sounds likely not to be an issue with the harness, but the capabilities of the models you've tried.

I experience almost no tool call failure using my nothing-special harness and DSv4 Flash.

Not sure if intentionally meant as a reference, but it gives "I use Arch btw" vibes.

and the interesting thing about system prompt wastage is its a cost that scales non linearly with subagent use.

I wonder if a lot of the 33k is context, like from recent conversations.

Cost, mainly. The runs went through a Claude Max subscription rather than metered API billing, and pinning an older stable snapshot kept run-to-run comparisons clean and cheap. The fixed harness payload (system prompt plus tool schemas), so the headline numbers shouldn't change too much.

That said, happy to re-run the matrix on Fable and publish the diff; payload figures should barely move, tool-calling behaviour might.

Gateway:

Meridian (github.com/rynfar/meridian); proxy that bridges the Claude Code SDK to a standard Anthropic endpoint so a Claude Max subscription can drive OpenCode-et-al.

It's the auth route for all agent traffic on the machine, not something built for the benchmark.

I find it hilarious people think they can build on slop or on captured output from quality engineers. Intent is the most important aspect, and no code base could ever capture that

-- note: I've been full time in Beolis for some months already, feedback welcome ;)

I vaguely understand you argument with the context, however is that not solved by sum agents handing their results in to the planner (or a third agent) to run on them again? I'd assume that's what is happening anyway. Let me know if that's wrong

> In version 2.1.63, the Task tool was renamed to Agent. Existing Task(...) references in settings and agent definitions still work as aliases.

https://code.claude.com/docs/en/sub-agents

1. Agent("Test")

2. look at your token usage

3. Repeat a few times

I didn't check again as I type this message but am somewhat sure subagent doesn't cache system prompt as of maybe last week

But I'll investigate how that works in a session. You got me curious.

Anthropic even changed this silently: https://www.reddit.com/r/ClaudeAI/comments/1sk3m12/followup_...

Except there’s a competitive incentive to either use less tokens or make the tokens go further

I'm generally against this context pruning without prompting or details. Sleev is very opaque about how it works and definitely will bust your cache.

I am a bit surprised that you're disappointed that it does exactly what you told it to - people usually have the opposite complaint.

If you're using it interactively and watching what it changes, I'd trigger the tests when you think it's needed. And if you want to go more hands-off, why not add try to encode the same nuance you'd use into the rule?

A major complaint with AI code was that AIs struggle with complex codebases, don't respect existing conventions, reinvent functionality multiple times over, etc. So, newer high end AIs are tuned with the "explore/exploit" dial turned towards "explore".

You could probably get it to do things "quick and dirty" with prompting, but that, of course, requires prompting for it.

I write a good prompt, paste the code then copy the output code and place it into my project.

So in the end I hand assemble and I only give it what it needs to know so no extra context wasted.

The human in the loop is of course the secret sauce but this way I am highly efficient, no vibecode and I work really fast too. Everything is audited.

You could probably engineer your own harness or workflow to warm the cache by running a single warmup agent, but this is not at all how the tools behave out of the box. It's mostly a cost optimizaiton, so Anthropic really don't have any incentive to do it proactively, and if they did, surely they would want to tell their customers how much they were saving?

I was simply supporting the article's data - their reported 33k tokens is probably roughly 150-165k.

On the other hand, the newer variants also tend to benchmark higher so it's not quite a clean argument of "hey the new version eats more tokens"

At this point I think Dario is just in his wellness retreat adjusting a revenue/profit dial.

Every time I read this comments I have the feeling you are talking about mcp or sub agents, otherwise this makes no sense at all.

What do you miss? I ask because I do some heavy work with pi + GLM 5.2 (using opencode Go subscription) and my workflow is plan -> implement.

no amount of alignment will stop aomeone drom just shutting up.

They get lock-in, and through that lock-in are more effectively able to inflate token usage.

To remind Goodhart's law: "When a measure becomes a target, it ceases to be a good measure".

..also to parent's point, yes the upsell is only appealing once user run's out of tokens.

I don't fully agree with the premise that they intentionally increase system prompts, but the enterprise plan usage is going to make that a huge income for Anthropic.

Anthropic is fine, as long as someone else (a clueless employer drinking Dario Koolaid) is paying for it. But the moment you have to pay for it, people just bail and go for DeepSeek, Kimmi, OpenRouter, OpenCode Go and other alternatives that give more bang for the buck than Anthropic.

There is a world where, to hit the next quarters revenue projection, you add 2,000 tokens to the system prompt and "beat" expectations at the next earnings release.

All the while, it could have just done a two-line probe test and see what happens when it calls the API with "None" for that parameter. Or just assum it would act as expected and wire in debug logs in case it doesn't.

Although saying that out loud makes me question it - each per-user chat and growing cache would need eventually to own its own ~contiguous memory block.

The downside is the code isn’t as good but it is produced a lot faster and more cheaply and often it’s actually fine.

CoT has made LLMs better (say 50% improvement or something) but increases cost by an order of magnitude. That graph is going in the wrong direction and has been for a while now

Its rather frustrating, slower tokens and more tokens.

https://app.codecrafters.io/catalog

To learn yourself:

<$20 on a cloud AI api for a chunk of tokens and have the AI teach you. "help me write an AI Agent using (language) and walk me through the steps"

Realize that these agent are REPL/while loops that maintain a conversation state and then based upon the tagging syntax like <TOOL:bash:uptime>uptime for system run time</TOOL> and the agent extracts the tool and then does sub commands.

"Pi has *ALL* the tools, can you name one it does not".

https://gist.github.com/joshcartme/dd71df7b4c51c356760b28d7f...

Increase the price by 70% and then cut it by 50%, resulting in a 15% cut that sounds like a major deal.

I now have unlimited Anthropic and OpenAI plans at work because CEOs bought the hype.

But for personal projects $10/mo OpenCode Go serves me with DeepSeek V4 Flash, MiMo 2.5 and GLM 5.2.

Especially since compute is such a scarce resource.

Incidentally, I also have zero supply chain attack surface as I have zero dependencies in my agent, just go stdlib. Pi, again, has 130+ transitive dependencies asking me to trust the security of my system to 150+ additional people I've never met in exchange for a bunch of bloat I do not want.

Sure, but you have to add almost everything, no? It deliberately only comes with read, write, edit, and bash. My point wasn't that you can't add stuff, but that I'd just rather use an harness that's a bit more full featured from the start.

(Pi is a bit like old 3D printing where fettling the printer to work is a central part of the hobby. I'd rather just buy a Prusa.)

If going local, llama.cpp is going to be the more beginner friendly local inference engine that supports more processor types (AMD GPUs, Intel GPUs, CPUs, anything that supports Vulkan, not just Nvidia). LM Studio is a nice wrapper for this if you'd rather avoid cloning repo and compiling yourself, provided you don't mind closed source software; it's much less enshittified than Ollama.

If going local, you will also need model weights in the right format for your inference engine, and with a model that can fit on your hardware. This is going to be .GGUF files if you're using llama.cpp or a wrapper for it like LM Studio.

From there, pick a language, go look up the OpenAI /chat/completions API format (or Anthropic's "Responses" API format), create a DS or array or slice to store messages, and build a loop that accepts user input, formats it according to the API format, sends it to the inference server, retrieves and parses the response, adds the response to the DS/array/slice, and repeat.

There's a lot more beyond this - tool calling, other API formats (optionally), MCP servers, transport layers besides terminal stdin/stdout, permission models, starting with a system message, clearing your message stack correctly (hint: don't reset it mid tool-call), message compaction, web searching and page fetching, semantic search RAG over embeddings, memory layers - way too much to cover exhaustively in a single message.

Also I think it’s well known that OpenAI is the much less expensive option (in tokens and $$). For the same $20 you get a lot more mileage.

Curious if folks have strong opinions about the overall UX of OpenCode vs CC…

It’s like that saying “What Andy giveth, Bill taketh away”, but in this case it is one company.

There is definitely a conflict of interest.

And people paying $100 or $200 are much more likely to max it out for purely psychological reasons - it crosses that threshold where I want to see my money's worth in full. Whereas people on $20 subs are more likely to be there just to get access to better models and features, and are not necessarily even doing any substantial work.

I think that Anthropic will bill you in any case :D

But yes, anything you want to ensure really needs to be a hook.

edit: realizing with "precommit" you probably meant a git hook not one in their harness. I'd have written the same response more or less though. :)

I feel like most mainstream programming languages do this sort of work for their standard libraries and their official docs. Go and Python come to mind, but plenty others do this reasonably well to the point where one mostly doesn’t need to read the implementation code to effectively use the standard library itself.

I enable tools specific to each project only in that project, and have very very few in my global config. Like <5k tokens worth.

Depends what I want but I can give a completely new context for every generation.

I try to make everything as simple and human readable as possible because I want the audit to go fast.

I think for me I lean towards an audit optimized approach. Everything is still generated but revolves around the human-in-the-loop for review.

Give it only what it needs and do things usually 1 file at a time.

Feels like I'm a sort of manual tape editor, if the context was a tape fed into machine, I assemble that and then watch the machine output the results I need.

Current /context on a fresh session (compare to that above) is:

  Opus 4.8
  15.8k/1m tokens (2%)
  System prompt: 4.5k tokens (0.4%)
  System tools: 7.9k tokens (0.8%)
  Memory files: 441 tokens (0.0%)
  Skills: 3.1k tokens (0.3%)
  Messages: 8 tokens (0.0%)
  Free space: 984.2k (98.4%)

I would also just vibe it if there is no responsibility, but if I do it that way I don't even care what happens with the project.

I get so detached from it that I stop caring and if it has huge critical bugs..I just don't care anymore because it's not my responsibility or my code at all at that point. I'm just there to nudge things along.

Just hook it up to Jira and let the managers add the features then pass it off to QA.

Real engineering is fully automated at that point.

The only issue is that Anthropic optimizes the entire experience for their bottom line. User experience and price only suffer becaue of that.

The nefarious part is because it's non optional. They could give you an option and compete by being better, instead you're given the finger as the option is taken from you. Competition is hard and banning people to create more FUD serves business need better.

You've obviously been gaslit so badly you're desperate to find a way to defend a shitty move and pretend it's the only way to increase usability. But you don't have to deny really! You're allowed to admit control is easier for a company than competition, and that they didn't have to, but did because it increases their control of the ecosystem.

If you want to defend someone, good? But at least save it for someone who actually deserves it. They don't; and you insult you and your readers intelligence by trying.

So what? When you care about optimising the entire experience, you offer sane defaults.

When you prevent people from changing the defaults, it's about control, not experience.

Its not 'nefarious' in that its in their best business interests.

But it'd be difficult to take anyone serious who thinks Anthropic's motivation was to improve the UX, and the other effect were by accident. At the time they specifically started blocking based on openclaw prompt text. Its a walled-garden tactic.

A walled garden is nefarious to people who do not want to be inside one.

Also i doubt there was jira ticket with “make llm more verbose”, rather ticket with “bug makes llms too verbose” gets prioritised taking revenue impact into account.

Your gym members who got a subscription aspirationally and don't show up are absolutely subsidizing the power lifter who is introducing wear on (tens of?) thousands of dollars of equipment three times a week, but if the regulars weren't there you wouldn't have sold those subscriptions at all. Without a poster child there's no poster.

But then you could just be storing up a lot of problems…

Yep, 100%.

Business has made it clear they don’t care, so there’s no point in burning one’s energy. Throw the whole thing on auto, check out, and go do something else during the day.

I say this as I don't actually know how Clade Code does this, since it's not open source, but I fail to see why two agents doing the same thing launched at different times would have different tools and system prompts.

I fully agree.

> It's the same conflict of interest quite literally any business has.

I know that you know what I meant ;) In the long term it is just as you say - overcharging (eventually corrected by competition forces), but in the short term it can be additional revenue, blamed on a bug, but making some manager look good.

For reference, pi-coding-agent, by itself (not including dependencies, tests, or pi-ai, pi-tui, pi-agent-core, etc), is ~41,653 SLOC taking up ~1658.9 KiB across 163 files.

My agent, excluding dependencies (all go stdlib) and tests, is 3 files, 946 SLOC, taking up 36.3 KiB, and includes a basic TUI and an XMPP transport channel (including TLS for XMPP), with dynamically configurable delivery to and receipt from either or both, including allowlists for XMPP message partners. It has tool calling, a permission model with whitelisting and interactive permission querying on a per-tool basis, full thinking support, including the ability to toggle hiding or showing it across either or both transports repeatedly throughout an individual session, the same tools as pi comes with out of the box, plus web search, and a tool to vet, build, and git commit golang projects all in one go, stopping if errors are observed. Configurable model and endpoint, too.

Incidentally, the open source xmpp server (prosody) and metasearch engine (SearXNG) are both self-hosted, too.

I've heard really good things but that being my first experience with pi didn't fill me with confidence about it's code quality either.

For now I stay with OpenCode I think - I was using zed editor and agent for the longest time anyway and think I will go back to that. CLI tools for me seem a bit too disconnected from the code.

It's still questionable but I don't think it's in the same ballpark as what you describe.

If you make a bunch of identical API calls quickly, before the initial request completes its cache write, you will have cache misses.

If you make a single API call to warm the cache, then make a bunch of subsequent identical requests, you will have cache hits.

The optimization for this sort of thing is to deduplicate in-flight requests, but i've seen no evidence that is being done; the better design pattern would be an api or tool call that explicitly launches multiple agents after a shared prompt processing stage

If that's what you're doing, you're fucked (in today's society, at least). What happens to your job when they figure out that's what you're doing?

Though, imo, the fact that pi maintains its "we only include the bare minimum!" statement is part of the draw for me. Especially considering that im in an enterprise env; being able to internally share custom implementations of out-of-the-box Codex/CC stuff is really nice.

I do wonder how they'd go about shipping a default web search tool. Big problem there is the lethal trifecta. Shipping something that arbitrarily allows untrusted content to be retrieved non-deterministically I'm sure is a long conversation on Pi's end. Pushing it off to the user to decide is easy.

I agree, that work in these places is likely short lived, if for no other reason than working in them is awful and demoralising. My point is, that these places exist, and have such a hard-on for “oh my god, AI!!!1!1!” that putting in extra effort there, is a waste of your own energy.

Edit: suppose that very well could have been tongue-in-cheek.

Side note: as someone who has been interested in programming for a while, but didn't end up in a software dev track in life, it's been pretty wild watching the ride you all have been going on lately. I used to be pretty bummed I didn't get to do that kind of work for a living, but lately I've been feeling more and more like I dodged a bullet.

Not that I don't have my own AI-related junk I have to deal with where I did end up, of course. I think most have.

You can just answer the same rote questions to different companies for max salary, then when the going gets tough you can essentially 'fire' the company and say they've moved past your core consulting paradigm. Maybe suggest a new consultant and move one. Rinse; repeat.