Fable 5 just left your Claude subscription. Here's how I keep Opus at that tier.

clomia — Tue, 07 Jul 2026 04:24:47 +0000

As of July 8, 2026, Anthropic moved Fable 5 off Pro/Max/Team subscriptions and onto usage-credit billing. The Mythos-tier model a lot of us leaned on is now a pay-per-use add-on.

Before you top up credits, a reframe: on the long, autonomous runs where Fable 5 felt irreplaceable, the bottleneck usually isn't raw model IQ. It's that Opus drifts off-mission and loses the goal to auto-compaction. Fix those two things and Opus punches far above where it feels on a multi-day task.

That's what I built ploop for.

What it is

ploop (Overclock Loop) is an autonomous loop for Claude Code, built for missions that span hours or days. You hand it a mission once; it keeps Opus on-target and self-checking until the work is actually done.

How it works

An isolated advisor, every round. After each round of work, a separate advisor subagent reviews what the main agent did and surfaces the blind spots it missed — the uncovered angles, the skipped edge cases. That advice is injected into the next round. Because the advisor runs in its own context, it isn't carried along by the main agent's momentum, so it catches drift instead of rationalizing it.

The mission survives compaction. On long runs, auto-compaction quietly drops the original goal and the agent starts confidently doing the wrong thing. ploop preserves the mission outside the transcript and re-injects it on every compaction, so the goal never decays.

Subscription-safe by design. The naive way to drive a loop like this is spawning claude -p from a hook — the exact automation pattern that risks Pro/Max account bans. ploop instead runs on nested subagents (the official Agent tool), so it shares your normal session quota and stays inside your subscription. No credits, no ban risk.

No round cap. The loop ends when the advisor has nothing left to add — a semantic finish, not an arbitrary counter. You can stop it anytime with /ploop:stop.

Install

Requires uv, and Auto-Compact must be on. Recommended model: opus[1m].

claude plugin marketplace add clomia/claude-automata
claude plugin install ploop@claude-automata

Then:

/ploop:define-mission        # write your mission
/ploop:launch [your mission] # in a fresh session

Try it

It's open-source (MIT): https://github.com/clomia/claude-automata

If you're staring at the Fable 5 credit prompt right now, point ploop at a real multi-day task on Opus first and see how far it gets. Feedback welcome.

I built a Claude Code plugin that finds what your agent can't see

clomia — Fri, 10 Apr 2026 08:04:55 +0000

TL;DR: Not "think deeper" or "try again" — "look where you haven't looked." Parallax spins up a separate agent with no shared conversation to find regions your main agent never considered.

claude plugin marketplace add clomia/claude-automata
claude plugin install parallax@claude-automata

Then append parallaxthink to any prompt.

The problem

You know the pattern: you give Claude a complex task, it finishes, and something's clearly missing. You re-prompt, re-explain context, wait again. Maybe 3-5 times.

LLMs narrow their exploration as they generate. Each token constrains what comes next. The bottleneck is thinking breadth, not depth. (For the curious: GPT-4 goes from 4% to 74% on Game of 24 just by exploring multiple paths instead of one.)

Self-correction within the same context doesn't fix this either — it tends to reinforce what the agent already believes rather than surface something new.

What Parallax does

Every time your agent tries to stop, Parallax intervenes:

A separate analysis agent spins up — fresh context, no shared conversation history.
It reads through your codebase (read-only, can't modify anything) and identifies regions the main agent never considered.
If it finds something, it injects the feedback and the agent keeps working. If nothing's left, it stops.

Cap at 30 rounds, typically finishes within 10. Each round, the analyzer deliberately picks the region farthest from what's already been covered, so it doesn't repeat itself.

Your original prompt is captured at the start, so even after auto-compaction the mission doesn't drift.

How it differs from existing approaches

Different layers, different problems:

"Think deeper" (e.g. extended thinking) = more reasoning budget in the same context
"Try again" (e.g. retry loops) = fresh instances, but prior direction often carries over
parallaxthink = find what you missed from a completely separate context

They're not competing. They stack.

What this actually looks like

My setup in Claude Code: opus[1m] + /effort max + thinking mode + parallaxthink + remote-control — that's max-context Opus, maximum reasoning effort, extended thinking enabled, Parallax active, and remote-control mode so I don't need to approve each step. Craft a solid prompt, dial up the reasoning, and let it go. Walk away, come back hours later, done. Parallax keeps pushing the agent into regions it would never have explored on its own — round after round, autonomously. No re-prompting, no re-explaining context. Just one prompt.

The stronger the reasoning, the better Parallax works — the analysis agent needs to actually think to find meaningful blind spots. That's why I run it at max effort with opus.

Limitations

No formal benchmarks. Run /parallax-log to see exactly what the analyzer found each round and judge for yourself.
Each round adds analysis overhead. But compare that to re-prompting and re-explaining context 3-5 times.

Source

Fully open source: github.com/clomia/claude-automata

Architecture diagram, docs, and all prompt templates are in the repo. Feedback and issues welcome.

DEV Community: clomia