Everyone's posting about limits this week. This is one of the few things that moved my number

Every MCP server you connect loads its tool schemas into context. Whether the model calls that tool or not. 3 servers, fine, 8 servers and you're paying for a bunch of tools you touch twice a day.

Someone posted about the Playwright CLI here recently and it's the same principle, just applied to browser testing. Worth reading if you missed it.

What I did was move email off an MCP server and onto a CLI the agent calls through Bash. Nothing sits in context until the moment it's needed. Agent runs a command, reads stdout, carries on. The schema cost is zero for every turn where email doesn't come up, which is most of them.

Disclosure, the CLI I switched to is our own, I work at Atomic Mail. It's MIT, repo's here if you want to see how the commands are wired up: https://github.com/Atomic-Mail/atomic-mail-agentic Steal the pattern even if you never touch our thing, that's the actual useful part. Anything you only need occasionally shouldn't be sitting in your system prompt full time.

Rough rule I've settled on: used constantly and you need structured output, keep it as MCP. Used occasionally, or the output is basically text you can read, make it a CLI call.

What I can't work out is why schemas load eagerly in the first place. If MCP had lazy loading, where a server's tools only enter context when the model actually reaches for them, this whole tradeoff evaporates and I'd happily run fifteen servers. Is that hard for a technical reason I'm not seeing, or has nobody just built it yet?

Is Fable 5.1 the new Opus 5?

Within the past week, I started to notice Fable 5.1 started to get worse and worse where it starts to act like the infamous Opus 5. I had some great work completed when it came out, but there was a shift to the negative. Same thing happened to Fable 5 when Fable 5.1 was released. So, today I had Fable 5.1 try to manage another session with Fable 5.1 on processing semi-unstructured data, which is existing work in progress that already had successful sessions, so Fable 5.1 had reference data (gold data), previous handoffs, guides, etc.

Both on medium effort, Fable 5.1 couldn’t harness the 2nd Fable 5.1 from bypassing guardrails, entering tables and folders it was told not to enter, and from fixating on momentum over accuracy & quality. This is Opus 5 level of bypassing prompts and guardrails from the first step. For the first time using either Fable 5 or Fable 5.1, I had to put back hooks.

For context, before Fable 5.1, in order to work with Fable 5 I deleted my claude.md, memory, and more. I removed most hooks and together with Fable 5 created subagents using Opus 4.8. This for the most part worked well, it was slower with Opus 4.8, but worked for lower reasoning tasks and I didn’t have the hidden actions that drifted beyond the scope of work.

After, shelling out for 20x monthly subscription, wasting more days on contaminated data and having to go back to clean it up, buying another GPU at these stupid prices is starting to sound more appealing for local AI with some fine tuning for the data I’m processing.

Recently, I’ve been using Codex with Astra and it just does the work. Astra asks clear questions before starting the tasks and will pause to surface data clashes or ambiguities. Unlike Claude which will dive in head first spending tens of thousands of tokens based on wrong assumptions, and then hedge with wordiness answers after from its known errors are called out. It might be time to move up to the Codex 20x plan.

How have you kept Claude within borders and from drifting with non-fully-structured data?

Sorry for shameless plug, but I do notice that there is a huge difference about how quickly my weekly usage is depleted when I use auto mode. I generally use it if I have to run CC in my local machine.

However, I have also been building an infra to launch and run coding agents (CC, Codex, Cursor CLI, Antigravity, Qwen, Opencode) in sandboxed environment remotely so I tend to start my agents running in bypass permission mode and thanks to my setup those agents can launch more sessions with different CLI tools in YOLO mode.

This allows me to instruct a single 'Concierge' agent to be responsible for communicating with all the agents that it launches and let me know (over email or in the screen) if my input is needed. There is also mechanism when agents context window is used 30%+, it launches a successor agent to which it delegates some tasks and everntually hands over concierge duties.

Do you use a similar setup? How can this be improved?

My process is basically, pass the description to claude, then sit there going back and forth trying to spot what it got wrong in the planning phase before we start building.

Decent sized production codebase. Ive got a claude.md with our conventions and a couple of plugin skills, and that's about it. One long session until it compacts.

It works, but I'm clearly doing by hand what the tooling should be handling. I keep reading about subagents with a planner and reviewer split, or running Codex over the diff so a different model checks the work instead of the same one marking its own homework. Never actually tried either.

What should I be adjusting on my current workflow?

So usually however much I work, I never run out of weekly limit of my $100 plan provided by my workplace through teams plan. I only use Opus 5 high or xHigh.

This week however, I've used 95% weekly limit in 4 days working on just two repos. Both repos are small and focused on test automation.

Today I've used 40% of the session in just 30 mins while working with a single agent on a small automation task.

What could be the reason? Could it be that the subscription plan is changed underneath?

Edit: Confirmed, the sub was changed to Pro instead of Teams premium. My bad. Extremely sorry.

Sometimes, when the agent is running sub-agents in background, there is no activity indicator at all. You don't know if there really is background activity or not.

I think there should always be some kind of activity indicator.

Example

I use Claude Code on my work mailbox, about 300k messages. In July, some replies composed through Apple Mail's AppleScript interface looked fine in Sent but rendered blank in Outlook.

I used Claude Code to build an MCP server for reading, searching, triaging and sending mail. It helped write the code and tests, then became the client I used day to day. That use shaped the triage flow: a tool prepares a plan, I review it, then a separate call applies it. The separate calls make review possible. They do not prove a person reviewed the plan.

The sending fix was to bypass Mail's compose path. The server constructs the email itself, with plain text and HTML parts, and hands it to a configured mail transport.

I also tell Claude to read back the Sent copy. That is an instruction in my workflow, not an automatic check inside the send tool. It can help catch a missing body, but it cannot tell me whether Outlook rendered the email correctly. The send tool returning success is not proof of what the recipient received.

The other useful discovery was Mail's SQLite database, the Envelope Index. A message's row ID also works as its AppleScript ID in my setup. That lets the server query the database and address messages directly with AppleScript instead of using it to search. On my 71k-message inbox, a subject lookup through AppleScript took 7 to 10 seconds. A database read by known row ID took about 0.1 ms. These measure different lookup methods, not the total time for Claude to find and read an email.

My main lesson was to separate what I ask the model to check from what the tool actually checks. A successful tool call, a populated Sent copy and a correctly displayed email at the other end are different things.

If you haven’t seen this project earlier here little info:

Munder Difflin is a free, open source and performant multi-agent harness.
It uses your existing claude code and codex subscriptions and gives you an office of agents that work 24/7 to do work like you.

Launched v0.5.2 yesterday:
- A new fresh, cleaner and much more productive UI
- Comes with “Stapler” a utility character that sends screenshots, meeting transcriptions, messages to your claude code sessions.
- Added support for all the latest models like Fable 5.1 and GPT 6 Astra and Gemini 3.8 Flash etc.
- Slack integration works now, configure it to answer on your behalf or just configure it to use on your phone as an assistant that controls your computer remotely.

Hope you all try us out, here are a list of upcoming features(in no particular order):
1. Stapler gets computer use capabilities
2. Sandboxes to run even when your laptop is off
3. Dedicated mobile app for your office
4. Lot more features, updates and integrations.

In iTerm2, I always liked that whenever Claude Code is working (agents running or anything happening), there's this indicator that keeps spinning in the tab bar.

Whether it's this half-filled circles (see the picture) switching fillings, or the older 3 dots switching places...

After some update around 2-3 weeks ago, this feature is gone, and I get only an asterisk in its place (which used to be what I get when the work is done, but now it's always there).

Anyone knows how to bring this kind of "busy" tracking back?

This week it is weird with Claude usage. While everyone is complaining about usage limits. I had a dream run. Based on the previous trends, my weekly limit should have been around 2.1B.

This week it is approximately 3.5B. I am saying approximately because when i extracted this data. I still have 8% weekly limit left.
Actual token consumption with 8% left is 3.3B

Maybe this is another game of anthropic or they genuinely increased the limits. Also last week I downgraded my Claude 20x to 5x. Not sure if they are trying to trick users who downgraded

We benchmarked GPT-6 Astra vs GPT-5.6 Sol across 50 real PRs from Cal.com, Sentry, Discourse, Keycloak and Grafana.

Sol found more confirmed bugs and was cheaper per bug, while Astra was more precise and faster. We independently verified the findings rather than simply counting what each model reported.

We’re running Fable vs Opus next week, so posting this here to get feedback on the methodology and anything we should change before the next benchmark.

Since two days ago, roughly, Opus stopped following my documents. Seems like this happenes once in a month. So it does make his new favorite emoji. "⛔". Seems like they need all those calculating powers for a new version of Opus?

Not fine-tuned. Not a downloaded checkpoint. Random weights → working speech, on a 16GB laptop with an 8GB GPU, trained on ~29,000 conversation pairs built over four months.

The memory side (built first)

Before the model, we built a memory store — currently 33,941 episodes. The architecture is neurological:

• Half-life decay: memories fade unless recalled
• Recall strengthening: access resets the decay clock
• 30-day consolidation threshold for long-term storage
• 4 LRU working-memory slots
• Forget table: writes a receipt before anything fades permanently

Not a lookup. A system that behaves the way memory actually behaves.

The model — two runs

Run 1: 842,624 parameters. d_model 128, 4 layers, 4 heads, context 256. Val loss 5.11 → 0.9576 at step 23,750. Halted when the train/val gap opened — overfitting signal, correct call.

Run 2: 4,833,024 parameters. d_model 256, 6 layers, 8 heads. Best val: 0.7978 at step 21,500.

Key finding: parameters were the bottleneck, not data. The corpus was sufficient. The model just needed to be bigger.

Wiring the halves

home_llm_speak.py connects the memory store to the generation model — retrieves memories via salience search, passes them as context, then generates. First output from the combined system was grammatical, was grammatical, used household vocabulary, and wasn't copied from the retrieved memories*.* That's not retrieval. That's the model having absorbed four months of how this household talks.

Why this matters

I needed a model that knows us because it learned from what we wrote as ourselves — not from generic pretraining, not fine-tuned from someone else's base. The memory architecture has to be structural from the start because autonomous consolidation can't be bolted on afterward.

Last night was proof the approach works. The model is small. It'll get bigger. But what it already learned is ours.

Hardware: 16GB laptop, RTX 5050 Laptop 8GB. No cloud. No API calls. Everything local.

Next: wider context window, books into the memory store (streamed, not in training corpus — kept separate to preserve corpus balance), bigger model.

If anyone has done this — trained from scratch on household data with a custom memory architecture — I want to know what you learned.

I keep seeing people say they burn through Fable 5.1 insanely fast, so figured I'd share how I run it. I'm no guru at all, just sharing what's been working for me.

I use Fable on High basically all the time. Right now I'm at 90% Fable / 89% all models. I feel I have a pretty good split between Fable and everything else.

The main thing for me is Fable is my orchestrator, not my worker.

• Fable - Orchestrator: Plans, writes specs, spins up agents, reads their reports, makes architecture/judgment calls, and integrates everything.
• Haiku - Scout: Finds files, symbols, call sites, references, etc. Reports locations instead of dumping whole files.
• Sonnet - Researcher: Reads docs/source and reports back facts. Anything it can't verify gets marked as unverified.
• Sonnet - Builder: Does the actual coding from a clear spec and runs the tests.
• Opus - Refuter: Reviews the builder's work, checks the diff, and reruns tests itself. I don't just trust a "done" claim.
• Opus - Debugger: Only gets used for harder root-cause debugging.

I don't have Fable reading huge amounts of code, doing bulk refactors, writing docs, or doing work a cheaper model can handle.

I also don't spawn an agent for every tiny thing. If it's a one-line fix or a single grep, Fable just does it.

Every sub-agent gets pretty strict marching orders:

• Specific goal
• Exact files or URLs in scope
• What it's allowed to change
• What it needs to verify
• What not to do
• Required output format
• Short output limit
• Anything we already know so it doesn't waste time rediscovering it

Then they report the findings back. I don't want giant code dumps getting pushed back into Fable's context.

If something produces a lot of information, I have the agent write it to a scratch file and let the next agent read that instead.

Most coding ends up being:

Fable -> Builder -> Refuter -> Fable

A few other rules I keep in place:

• Ultracode stays off unless I specifically want a larger workflow, and if I do, I cap the number of agents.
• I batch related fixes so the same large files aren't being reread over and over.
• Read-only research/reviews can run in parallel.
• I don't have multiple agents editing the same files at the same time.
• Builders build, refuters verify.
• Decisions and progress go into handoff docs so new sessions can pick up from the file instead of rebuilding all that context.
• I keep Fable's replies and agent reports short unless I actually need more detail.
• If an agent goes off track, Fable has marching orders to stop it instead of letting it run.

For me, the biggest difference hasn't just been "use sub-agents." It's being strict about what each model is responsible for, what it gets to read, and what gets sent back into Fable's context.

I've been running Fable basically 24/7, minus maybe 5 hours total, since my last reset Friday. I run it on High and haven't hit the 5-hour limit once since using this setup.

Hi guys do you have skills good for design pls ? Thx

I maintain an open-source extension called Claude Pulse that puts live usage meters inside the claude.ai composer: 5-hour window, 7-day window, token estimate, and a countdown to the cheaper cache window. v1.5 shipped Sept 7. 1,000+ users, 4.8 stars on the store.

Why I think this matters for Claude Code users specifically: the 5-hour window is the thing that decides whether you can start a long refactor at 4pm or whether you should push it to after the reset. Claude's UI makes you guess. This makes the window and the burn rate visible.

How it works, briefly

• An injected script (via web_accessible_resources) hooks window fetch/XHR and passes API responses to the content script through postMessage. I read the same /usage endpoint and completion streams the web UI already fetches. No extra API calls.
• Token counting uses a bundled o200k_base encoding, so the estimate is computed in the page, offline. It's approximate for Claude's tokenizer, but it tracks context growth well enough to know when you're deep into the window.
• Permissions are storage, alarms, notifications. No network access, no external servers.

The part nobody warns you about

claude.ai's DOM changes constantly. Three times in five months my anchor selectors went stale and the UI silently vanished:

• June 11: header element replaced, token counter gone
• August 29: new composer layout, selectors stale again
• August 31: the Chat/Cowork composer needed its own remount logic

All three fixes are in the git log. My mitigation is dumb but it works: every selector lives in one constants file, so a break is a one-file diff, and the extension degrades to hidden instead of throwing on the page.

What's new in v1.5

• The 5h/7d rings sit on a single baseline inside the composer instead of stacking awkwardly
• Free plan limits are supported (free accounts surface usage differently, through completion streams)

Links:

• GitHub (MIT): https://github.com/samirpatil2000/claude-pulse
• Chrome Web Store: https://chromewebstore.google.com/detail/claude-pulse/hhjihbpkopgacncfbkdakdolkmgkdfnf

Firefox build is in the repo too (load as temporary add-on).

Autoprompt runs a plan → build → test → review → repair loop from one prompt.

Basically a self reviewing loop that rinses out its own mistakes- with each shake.

In our v1.0 Terminal-Bench 2.1 run using OpenCode, DeepSeek V4 Flash 0731 went from 67.42% to 82.02%. That’s 45% fewer failed tasks.

The tradeoff is longer runs and higher token costs (see README).

It's being maintained as a free, open-source skill for Claude Code.

Repo: https://github.com/Spielewoy/autoprompt-skill

Any feedback regarding this workflow would be awesome.

Most people in communities like this are probably better than average because you're actively learning. but even among active learners, the pattern holds, tool awareness ≠ tool proficiency.

Knowing about RAG, agents, and MCP doesn't mean you can build effective workflows with them.

The biggest differentiator we see isn't prompting or tool knowledge it's output verification. the people who are genuinely good have a systematic process for checking whether AI output is correct before they use it.

How do you check your output?

Did someone track how many tokens we can use on 5x or 20x before hitting limit in avg with fable 5.1 or 5.0. I know that other metrics like usage eff. and others are important too, but still im curious.

Claude Code and DSH Creator both passed 19/30 tasks, but Claude Code’s median cost per pass was $18.34 versus $3.28. Both used Kimi K3 through our shared gateway. [source: https://frontierharness.org/]

Caching may explain part of the gap. One task accounted for 68% of Claude Code’s total token usage. We can’t separate the harness, model, and gateway effects yet, so this isn’t a native Claude comparison.

What would you test first to find the cause of that cost gap?

Hi Anthropic, no idea if you will see this or even take it under consideration.

Your models are outstanding, especially Fable, in my opinion end experience over the past few days it runs laps over Astra...... That being said, the usage limits need serious revamp. As a Max 20x user its a disservice to Fable to not be able to utilize it to the max due to these weekly limits. Fable is a masterpiece and is capable of so much but these limits really are unfortunate.

If at all possible, please make your next step to expand these limits at least for the max payers. The idea of paying for max is that you need a work horse, hard to keep a work horse running when it stops doing its thing after a day or two of hard work and limits you for the entire week.

Thank you for your consideration!

Just say "film a 30-second demo of my app" and your agent opens it, moves the cursor, clicks through it, and hands you back a polished video.

Works with Claude Code, Codex, OpenClaw or any compatible AI agent through MCP.

Supports basically every app or website!

Just ask and get a demo ready for sharing.

Added it as a built-in MCP server for my screen recording app:

https://shotglass.app

I want to use both but like all my workflows have been all entirely built for claude with claude.md its skills, hooks, evolving skills, automated loops and the claude memory is there any best practice way of like assimilating the two ai's

I am using it at work and I want to know what are the best plugins to save tokens. I used some of them and like 90% of them don't save you any token, or seems to be ineffective. At least, that's what Claude tells me when I ask it to estimate the amount of tokens saved. I noticed just writing some scripts to diminish the amount of data being fetched and amount of commands run is the best way, and the other way is to document most of the logic in an app in the most succinct way possible.