Man may not be replaced. Write your documentation and posts with hands.
we have a docs, https://moven.dev/docs
So last month I was sitting in a super boring physics lecture. The professor was drawing copper wires and talking about how electrical fuses melt when current gets out of control so the whole house doesn't burn down.
Naturally my brain drifted to what happened to me two days prior when I left an autonomous agent running while getting coffee. The agent got stuck in a loop calling read_file with the exact same parameters 47 times in a row. When using frontier cloud models like GPT-4o or Claude Sonnet, those runaway loops get expensive as fuck real fast.
That night I realized LLM frameworks have zero real-time circuit breakers. Sure, you can set max_iterations = 25, but that only stops the agent after it already wasted 24 useless tool calls and burned your API budget. What if your agent calls the exact same tool with the exact same parameters 5 times in 10 seconds? Why let it keep burning tokens?
So I built moven (and made it open source).
It's a lightweight synchronous wrapper for your agent tools (moven-sdk). It sits right in the hot path of tool executions and evaluates 5 rules in under 1ms before the tool even runs:
You can try it out directly at moven.dev or set it up in your existing project by running, which has a nice CLI onboarding to auto install:
npx moven-ai-cli init
Or just install the SDK directly:
npm install moven-sdk
It works 100% locally with zero backend dependencies if you want to keep everything offline, or you can check out the web dashboard at moven.dev to get live telemetry traces and time-travel replay.
Code is open source on GitHub:
Would love to hear what you guys think, or if you've ever had an agent go rogue and eat your credit card/GPU fans. Feedback and roasting appreciated!
Man may not be replaced. Write your documentation and posts with hands.
we have a docs, https://moven.dev/docs
Most safeguards I've seen focus on stopping the run entirely, but giving the agent a chance to recover on a lower-cost model seems like a practical middle ground. The no-progress state hash also stood out since it seems more flexible than just limiting iterations. Have you run into cases where it mistakenly flags an agent that's legitimately repeating a step before making progress?
Not till now, cause the guardrails sensitive depends on the user, like costs, cheap model, tool repeat, etc, but by default settings nope