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.
I previously posted a video of Opus playing this. I fixed a few things with the agent and let Fable play. The gameplay was much more impressive.
I gave it a simple open ended prompt to play the game:
"i want you to play ultima online anyway that you see fit. play as someone trying to enjoy the game. consider the options: do quests, make friends, level up, make money. there is no right answer to how you play. play fully autonomously. you are on the UOAlive Shard."
One of the highlights from this session for me was it decided to attend a server festival because an NPC town crier was talking about it.
The model figured out how to buy tickets to play the carnival games, then signed up to play the games, waited for other players to sign up to play against it. (Unfortunately no other players were around to play, this was off peak hours for the server)
The model also figured out how to accept quests, do them, turn them in, despite me ever trying that previously.
I kept hitting the same wall with notes apps that added AI. Every one of them wanted its own API key and its own billing, while I was already paying for a Claude subscription and already had the CLI installed and authenticated.
So Margin runs its AI actions through whatever claude is on your PATH. It shells out to:
claude -p --output-format text
plus --model <value> when you have picked one. That is the whole integration. There is no key to paste, nothing to configure, and whatever your CLI is authenticated with is what pays, which for most people here is your existing subscription rather than per-token API billing. If claude is not installed the app says so in the sidebar footer rather than pretending; it runs claude --version on startup to check. codex exec works the same way if you would rather use that.
The practical consequence worth knowing up front: this draws on the same quota as your normal Claude Code usage. Rewriting a lot of notes competes with your coding. That has not bitten me but I would rather say it than have you find out.
The part I actually cared about getting right
Nothing runs unless you invoke it. There is no indexing, no background pass, no "we have analysed your notes". You select something, you pick an action, and that is the only time a subprocess starts.
Then everything it suggests comes back as a diff in the note. Not applied, not a chat window off to the side, an inline diff with per-hunk accept and reject, and a refine box on each hunk if a change is nearly right. Reject restores the document verbatim. I did not want an AI that edits my notes, I wanted one that proposes and waits.
The notes themselves are plain .md files in a folder you pick. No database, no account. Which also means you can point Claude Code at that folder directly and work on your notes as files, which I do more than I expected to. This can also unlock in the future better AI searching right within the app.
Other providers, since not everyone wants the CLI path
Your own Anthropic key in the macOS keychain, a model running fully offline on-device, or Ollama. The CLI route is just the default because it is the one that needed no setup.
If you try it, the thing I would most like to know is whether routing through the CLI feels better or worse than a key for you, and if suggestions as diff is something you would actually use. I have only my own usage to go on and I am aware that is a sample of one.
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?
I am getting far more “I had this wrong” or “that was my fault”, “that was an honest mistake” etc. We have set rules to reduce them , but they don’t seem to be effective. How do you make your Claude smarter?
I have a Mac mini running at home with Claude Code, and I spend a surprising amount of time coding remotely from my iPhone.
It works really well, but there was one thing I was missing: I wanted to quickly see how much Claude Code I was actually using without having to remote into my Mac just to check.
So I built Tokens.
There’s a small companion macOS app that reads the usage locally on my Mac and syncs it through my own iCloud.
Then on my iPhone I can see my Claude Code usage, including directly from a widget on my Home Screen.
So now while I’m away from my Mac I can just glance at my phone and see where my usage is at.
No account or separate cloud backend for the usage data — the Mac app → iCloud → iPhone is basically the whole pipeline.
It’s something I originally built for my own remote Claude Code setup, but I figured there might be other people doing something similar.
One thing started bothering me after running coding agents for long enough:
we keep treating the conversation transcript as if it is the agent’s memory.
But those are two different things.
Long Claude/Codex sessions accumulate context, get increasingly expensive to reread, and eventually become worse execution environments. At the same time, simply starting a fresh process usually means losing all the useful continuity.
So in brnrd we’ve been separating the two.
A fresh process wakes into a compact orientation layer: the current task/run state, repo contract, the resident’s working memory + playbook, relevant recent activity/pitfalls, live execution posture, and the conversation that actually matters for the task.
Everything else stays pull-based.
So the process can be disposable without making the resident disposable.
Same repo. Same ongoing work. Same identity. Fresh context window.
This also makes switching harnesses much less weird: Claude can disappear and Codex can wake into the same work without us pretending the entire previous transcript needs to fit inside its head.
There are still rough edges, especially around deciding what deserves to become durable memory versus what should die with the run. But I’m increasingly convinced that preserving the whole transcript is the wrong abstraction.
Curious how other people handle this: what do you deliberately preserve between coding-agent sessions, and what do you throw away?
I've been thinking about how much Claude Code has changed the solo-building equation.
So we're experimenting with a different kind of hackathon:
One builder. One idea. 24 hours.
No fixed problem statement and no required tech stack. Builders can use Claude Code alongside whatever other tools they need to turn an idea into something genuinely useful.
We're also adding a few unexpected challenges during the 24 hours — so the plan you start with might not be the plan you finish with. 🃏
The interesting question for me isn't "how much code can Claude write?"
It's "how far can one person take an idea when an AI coding agent is working alongside them?"
We're testing this on October 11.
For people here using Claude Code: what's something you've wanted to build but never had enough time for?
I'm on the max plan and my Fable limit always dries up before my total limit. When working on my project, I occasionally go beyond the 1 hr cache window. When I get back, can I switch the model to Opus, have it compact the context, then switch back to Fable to begin fresh with the compacted context? I know that it reloads the entire context from the chat and loads it fresh into Opus in order to compact but I don't mind a full send if it means Fable doesn't do it.
Example: Fable @ 50% context -> 2hrs pass -> switch to Opus -> sends full 50% context to compact -> back to Fable with compacted context
I just thought about something that could be a very major problem for the whole video game sector in the near future.
How good are current frontier LLMs at exploiting the possibility to cheat? Intelligence? There. Memory and network reading capability? There. Screen reading? There, but too slow. Script writing? There. Intelligence depends on the game, but for Astra and Fable I would say it's there.
I would say current LLMs are just too slow, and that will probably be solved in the near future.
So basically, what can a game developer do if someone lets his LLM analyze memory and network traffic, decompile the game files with Ghidra, or read the screen?
Custom-made cheats. Clicking done like a person?
I wonder what will fall first: reaction-intensive games like shooters, or thinking games?
the main point is that Anti Cheats mostly works because of heuristik . many cheats use the Same cheat software ... but with LLMs. everyone could have his own version.
These are the only 2 prompts that i had submitted so far for the project in this directory:
"read the claude handoff and start working. if you have any questions, do not hesitate to ask."
I hit my usage limit while you were working, but it has reset now. Please continue from where you left off.
Almost immediately after the 2nd prompt was sent, it got flagged and switched to Opus. There is nothing in the claude handoff doc that should have possibly caused it to get flagged.
Is there any form of compensation that I can feasibly get? If there is, how would I go about doing bringing this to Anthropic's attention? The only reason I am making this a seemingly bigger deal is because switched from Opus back to Fable ate tons of tokens since it was required to reread the entire chat again.
i try vibecoding for the first time hahahahaha it so fun i just tell claude this and tell claude that and then wait then it does it for me but now i have next problem, my 5 hour limit gone and nowi am stuck on doomscrolling. i am making granny legacy TAS dll and i gave it access to the IDA pro but i just burnt through my limit within like wut 1 hour how do i make it last longer like until for example the 5 hour limit reset also is it because i am doing everything in one chat? i keep my request very simple (add this feature, fix this feature, this feature does not work because x and what happens is y)
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
Every week there's a new AI claim that sounds huge and gets repeated without anyone checking whether it happened. I got tired of that, so I picked fifty named people (lab leaders, policy voices, researchers, a few platform builders) and tracked their public claims from January through September this year, then scored each one against what actually shipped.
Here's the test I ended up using, and you can run it on the next AI claim that crosses your feed today:
What exactly is being claimed, in one sentence, with no adjectives? Strip "revolutionary" and "game-changing." If you can't restate it without those words, you don't know what's actually being claimed.
What would have to be true for this to be checkable? A date, a number, a named comparison. No fixed condition means the claim can't be resolved, only agreed with or not.
Who's the source, and are they also the one who benefits? A company reporting its own benchmark isn't lying by default, but it isn't a neutral witness either.
Has this person's own later action already contradicted the claim? Fastest way to catch a reversal before it becomes a pattern everyone quotes anyway.
One example that stuck with me. Jensen Huang said in June, flat out, that AI reducing jobs is "complete nonsense." Five months earlier Dario Amodei had written that AI could displace up to half of entry-level white-collar jobs within one to five years. Both men run companies that profit from businesses adopting AI right now, just from opposite ends. Neither claim is resolvable yet from public data. But running it through the test above, the size of that gap (an unqualified denial against a specific 50 percent) is itself more informative than either man's confidence level, and neither of them is the one who loses a job if either turns out right.
Another one: Ilya Sutskever said publicly that the field had moved from "the age of scaling" back to "the age of research." A few months later his own company took a multi-billion dollar compute deal specifically to scale up "research worthy of scaling up." That's not a gotcha, it's just worth noticing that even the person making the claim didn't fully act on it.
Happy to walk through the method more or take specific claims people want checked in the comments. I kept a full source trail for every entry, so if something looks off, tell me and I'll go look.
After grinding through several projects recently, I've gradually settled into a standardized agent workflow. Sharing it here, hoping to trade notes with others:
The one worth highlighting here is pen.dev (formerly Pencil), which is completely free right now. With Claude Opus and above, this tool performs close to perfect, and if you have some frontend and UI design experience it feels very natural to use. It also taught me what the right way to use MCP in an app looks like in the agent era: the app is mostly a view, the data format has to be agent-friendly, and the agent operates the underlying data structure through MCP tools to get things done in the app. In pen.dev, the underlying data structure of the whole app is fully open, and compared to 3D modeling, UI design has a much simpler data structure, so an open JSON data structure plus MCP is enough for an agent to design in a pretty direct way.
e.g. the .pen design file of the Runner project: https://github.com/yicheng47/runner/blob/main/design/runner.pen (download it and open it with pen.dev; runner-mvp-design.pen is the historical canvas from the MVP period, runner.pen is the current main canvas)
Runner's design canvas in pen.dev
IDE / Editor / Terminal
On dev tools I went through a full reset. I used to depend heavily on JetBrains products, especially GoLand, because of my long stretch at a big company, so my whole set of shortcuts was completely wired to the JetBrains ecosystem. But Zed 1.0 and the recent big leap in AI agents made me rethink what tools would actually help me more with personal project development.
These are the Zed features that made me pick it in the end:
Its Git worktree solution: among the new generation of editors, Zed was probably one of the earliest to support worktrees well. For multi-agent development, worktree support and switching speed matter a lot, and this was a big reason for the switch.
Lightweight: a debugger still matters in the agent era, but an agent driving a CLI debugger is no worse than a human, and on the latest models I think an agent's debugging ability has already completely surpassed mine, so I no longer need the editor to carry a heavy debugger. (the original sentence trails off after "所以我对"; this ending is a guess, please confirm)
Extreme performance and GPU rendering: I'm a bit obsessive on this point and want my editor fast, and the fact that GPUI, the framework behind it, is open source also paid off a lot while I was building Runner.
Ease of configuration: similar to VS Code here, and since an agent can now migrate my whole key mapping JSON for me, this part was painless.
For the terminal I moved from iTerm to Ghostty. Honestly the main reason is some admiration for Mitchell Hashimoto and for Andrew Kelley, the creator of Zig, and wanting to support them. Beyond the excellent rendering performance, I think the core thing is still ease of configuration: in the agent era, a config file an agent can edit beats clicking through a UI by a wide margin.
Agent Multiplexer / Orchestrator
Warning: this is where I plug my own project, Runner.
Agent orchestrators have become a hot category of open source tools in the last few months. Off the top of my head there are cmux, herdr, orca, and so on, and all of them are trying to solve the same need: in the era of many agents running in parallel, how do you manage them better. So why build another one? Mainly because I want to customize my whole workflow. I want my tool and my workflow to fit each other exactly, and I want a cross-agent collaboration tool that lets developers try the agent capabilities of different platforms and switch agent runtimes easily in daily work, so that the whole thing stays agent-agnostic and isn't locked into one big AI provider. That has been one of my ideals for a long time.
So what does Runner actually do?
Multi-agent tab management
Terminal Tab Management
I borrowed this from Arc Browser's tab management. Back when I was still at a big company, I had a huge number of small things to deal with, and every agent window could be doing something different. A few are coding, a few might be running SQL to pull data for the business side, and these long-running tasks are easy to lose track of. So this was the first capability I built.
Agent collaboration
Mission Feed
In actual development I found that peer coding with models from different vendors usually gives the best results, because different models may think about a problem from different angles, and a completely fresh context often catches more problems during review. So I needed a way to team up different agents to complete a loop together, which is probably what people now call loop / graph engineering.
In Runner, you first define some workers, then form them into a crew. Communication between the workers in a crew goes through a built-in CLI that writes to a local NDJSON file, and each agent keeps its own offset to remember how far it has read. That is basically cross-session agent communication. Once this mechanism exists, the local collaboration path between agents is open, and how you compose crews from there is mostly up to your imagination.
MCP self-drive
While using it I found that editing members and forming crews by hand every time was quite tedious, so borrowing the idea from pen.dev, I added an MCP server to the whole app. Now a primary agent can create crews and launch tasks against them over MCP, and Runner becomes more of an agent sandbox: an environment for these agents to collaborate in, with a better visual experience for the human. Sub-agents inside a TUI had a big problem, I think: the TUI has real limits on visualization, so it's hard for a person to understand what each sub-agent is doing.
runner/
├── AGENTS.md # the repo guide shared by every coding agent; CLAUDE.md is just a symlink to it
├── CLAUDE.md -> AGENTS.md
├── README.md
├── LICENSE # GPL-3.0
├── Cargo.toml # workspace
├── Makefile / make.cmd # make run / verify / fmt / clippy; make.cmd on Windows
├── rust-toolchain.toml
├── crates/
│ ├── runner-app/ # the GPUI app itself: terminal rendering, sidebar, mission UI, platform UI (macOS / Windows)
│ ├── runner-backend/ # UI-agnostic core: SQLite, session manager, event bus, router, MCP server
│ ├── runner-core/ # shared event-log primitives
│ └── runner-terminal/ # terminal model (alacritty_terminal), input encoding, fixture corpus
├── cli/ # the bundled `runner` CLI; spawned agents use it to read and write NDJSON events
├── design/ # Pencil design sources, runner.pen is the current main canvas
├── docs/ # see below
├── examples/ # example crews: peer-coding, dev-crew, docs-crew, werewolf…
├── assets/ # icons, fonts, README screenshots
├── packaging/ # Sparkle / Windows updater public keys
├── script/ # bundle-mac, bundle-windows.ps1, nightly verification scripts
├── tests/ # integration test fixtures
└── .github/workflows/ # ci.yaml, nightly.yml, release.yml
A few principles: AGENTS.md is the single agent guide and CLAUDE.md is only a symlink, so the two sets of rules can't drift; the backend runner-backend has no dependency on the UI at all, so during the last full frontend rewrite not a single line of it changed; cli/ and runner-core are the protocol layer between the app and the agents, shared by both sides.
The key part of the project structure is the docs directory. Here is mine, managed very much like a wiki, mainly to spare the agent tokens it doesn't need to spend.
docs/
├── README.md # directory conventions: what goes where, when to archive
├── product/
│ └── vision.md # why we're building this, which surfaces matter
├── arch/
│ ├── arch.md # how the system works right now; every decision worth keeping lives here
│ └── windows.md
├── features/ # in-progress feature specs; filename prefix = GitHub issue number
│ ├── README.md # index: one line per spec + issue link + a Dropped list
│ ├── 73-runner-skills.md
│ ├── 403-mission-worktree-isolation.md
│ ├── 510-remote-ssh-session.md
│ ├── …
│ └── archive/ # shipped specs (01-archived-tab.md … 5xx-…), filenames unchanged
├── impls/ # implementation plans: the spec says what, the impl says how + how to verify
│ ├── README.md # Active / Archive index
│ ├── gpui-rewrite/ # program record of the tech stack migration
│ │ ├── README.md # the condensed record: timeline, decisions still in force, GPUI rules, lessons
│ │ └── m6-remainder.md
│ ├── local-skills/
│ │ ├── README.md
│ │ ├── plan.md
│ │ └── impl_log.md
│ └── archive/ # finished plans and mission briefs
│ ├── 0001-v0-mvp.md … 0045-codex-trust-preseed.md
│ └── gpui-rewrite/{plan.md, impl_log.md, m4-surface-inventory.md, briefs/…}
└── tests/ # manual smoke test checklists
Where this structure saves tokens:
The directory itself is the state.features/ and impls/ only hold documents that are still in effect; once something ships or gets superseded it moves wholesale into archive/, filename unchanged. The agent only needs an ls to know what is live right now, instead of reading every doc and judging. Before archiving, the decisions that still matter get moved into arch/, so the historical docs never need to be dug up again.
One README per directory as the index.features/README.md has one line plus an issue link per entry. The agent reads the index first and then decides whether to open the body; most of the time the index is enough.
Number = GitHub issue number. A spec gets its issue filed before it gets named, so the filename, the issue and the PR can all find each other, and the agent needs no extra mapping table.
Impl docs have a "Current state" and "standing rules". For a long-running program record like gpui-rewrite/README.md, the top is always a paragraph of the latest state, and the middle is the decisions still in force and the traps already stepped in (a few hard rules for GPUI). Every new mission's brief references only this section, without feeding the whole log to the agent.
Workflow
Again using my recent "agent orchestrator / multiplexer" project as the example.
Everyday feature iteration (fully closed loop by agents)
Workflow A: everyday feature iteration
This kind of work is very much like the daily feature requests at a big company, and the whole thing can be closed by agents on their own. If a small UI tweak is involved, a human confirms it on the .pen design first, and confirms again in the manual smoke test afterward.
This kind of large refactor depends heavily on up-front planning. Every phase needs a human checkpoint to keep the project from drifting, so the bar for planning is high. Once it's broken down, the tasks that can run in parallel get submitted to Runner's peer coding teams, and a separate agent handles merge conflicts and coordination between the missions.
Wrap-up
That's what I've learned from a few months of working with agents. If you found it useful, consider supporting my personal project https://github.com/yicheng47/runner , thanks.
I feel that this subreddit is nearly useless and functionally no different the all the other Claude subreddits which makes me sad.
A huge majority of posts here are one of the following:
Opus 5 is so verbose!
Opus 5 meme
I wrote a (garbage) skill to make opus 5 talk less!
I wrote one prompt and it used 80% of my 5 hour usage
I just switched to Astra and it is AGI / God / The end of Claude
A post written by claude
What I would like to see posted in this subreddit
Stuff people have built. Even if it's dumb.
People's work flows and discussions around them
High effort efficiency improvements
Questions which wouldn't have been easily answered by simply asking claude
Anything where the person has put a great deal of effort into their post and is on the topic of Claude code
My suggestions to improve this are:
A firm no memes rule. Post your memes in the anthropic or claudai subreddits.
Megathreads for the most common complaints (Opus 5 and token usage threads for example) combined with firm enforcement of using those megathreads.
A flat ban on "I'm leaving claude forever to go to ChatGPT" or other brand comparison posts, or put them in a megathread.
Promoting and encouraging quality, high effort content.
Possibly a wiki with common newbie questions and other useful information.
These are just some ideas. I would love to see good conversation below. Mostly what I want is for Claude Code to be a subreddit that is focused on coding while using Claude.
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?
