u/Commercial2Toe

https://preview.redd.it/5w0wme402lbh1.png?width=1536&format=png&auto=webp&s=1bbf89e33d14d19a4c2ebddf2a2b1fac5b2195a7

I kept running into the same two problems with Claude Code on longer sessions: it'd get stuck retrying a failing command in a near-identical loop, and tool output (file listings, logs, diffs) would pile up in context even after it stopped being useful. Both quietly ran up the token bill.

So I built DedrooM a small middleware that sits in front of Claude Code (and a few other agents: Codex, Aider, Cursor, Cline, OpenCode) and does two things:

• Stops loops before they compound. Tracks repeated tool calls with an adaptive window, tightens up automatically once error rate climbs, and blocks a call outright if it's clearly stuck.
• Compresses redundant tool output before it hits the model — truncates repetitive stuff like long file listings, dedupes logs, keeps the parts that actually matter.

It's one command to try:

bash

pip install dedroom
dedroom wrap claude

dedroom unwrap claude puts things back to normal. It's Apache 2.0, source is here: https://github.com/Devaretanmay/dedroom

Being upfront about the numbers: the compression/savings figures in the README are from a handful of internal test scenarios, not a big benchmark suite real savings depend a lot on your workload (loop-prone sessions and repetitive tool output benefit a lot more than a clean session does). I'd rather you try it and tell me it doesn't do much for your setup than oversell it here.

Would genuinely like feedback from people running long Claude Code sessions especially if it either catches something useful or gets in your way. Happy to answer questions about how the loop detection or compression actually works under the hood.

I've been experimenting with autonomous AI agents over the last few months and kept running into the same problem.

Agents would repeatedly call the same tool, retry failed operations indefinitely, or get stuck in execution loops.

Instead of trying to solve it through prompt engineering, I built a small Rust library that sits between the agent and its tools and verifies every tool call before execution.

Current features:

• History-based trajectory tracking

• Loop detection

• JSON Schema validation

• Regex/exact policy rules

• Per-tool trajectory gates

• C ABI

• no_std core

• Python adapters for LangGraph, CrewAI, AutoGen and LangChain

Current benchmark:

~17 μs average verification

~375 ns fast reject for repeated loops

I'm mainly looking for feedback on:

1. API design
2. False positives
3. Whether this belongs as middleware instead of framework-specific code

Repository: https://github.com/Devaretanmay/microloop