You're pledging to donate if the project hits its minimum goal and gets approved. If not, your funds will be returned.
Github: https://github.com/rahulb0802/rewind-sdk
Demo (Loom): https://www.loom.com/share/3fd7a3cfa7f5461b982ff799f49dc817
PyPI: https://pypi.org/project/rewind-sdk/
Letting an agent write and execute code breaks things. There are three main problems with this:
1. Agents break things that don't have clean diffs that a tool like Git can revert. A corrupted database, a half-run migration, or a deleted binary asset has no way of being reverted efficiently.
2. Even when you do snapshot the filesystem, it can come with heavy overhead, such as booting up a VM. But more than that, the agent's memory doesn't sync with the changes, and the next turn reasons against a version that no longer exists.
3. Agents routinely declare success without verifying it, or crash mid-test, with no way to know if "it worked" is actually true.
To fix this, I built Rewind (rewind-sdk): an open-source SDK that syncs Docker+OverlayFS filesystem checkpoints with conversation-memory checkpoints, so one rollback call reverts both atomically. This includes dropping the dangling half of a tool call that failed mid-run, which prevents your entire history from being rejected by strict-schema providers like OpenAI. On top of that sits a three-state verification contract (pass/fail/unknown), an append-only ledger that survives rollback, and a human-in-the-loop escalation path for the "unknown" case most systems silently discard.
v0.3.1 is live on PyPI with a working LangGraph integration. The verification ledger design was proposed by a developer on Reddit after exploring an early build, and I shipped it within days because it was validated. That pattern of real usage and feedback shaping the roadmap rather than speculation is how I want this to keep growing. This grant covers the compute and infrastructure costs standing between where it is now and a version that's been stress-tested against real, concurrent, multi-agent setups.
The goal is to take Rewind from a working prototype validated on my own machine to something that works under production agent use. This includes multiple concurrent agents, real LLM providers under real load, and more advanced tool calls.
I'll do this by moving testing off my local machine and onto real infrastructure. This involves running the sandbox against multi-turn workloads instead of synthetic tests or rate-limited agent calls, and using that to improve the two things I already know are current limits: the isolation model (currently a privileged container, which is not a hardened boundary against malicious actors) and the framework surface (LangGraph only, so far). Where the current design holds up, I'll ship it. Where it doesn't is exactly the info I need to prioritize what gets built next. I want to let real infra and usage tell me what's actually broken rather than keep building speculative features on top of an untested foundation.
I am requesting $6,500 in funding as an individual incoming college freshman building this full-time over the summer.
Cloud Infrastructure and Sandboxing ($2,000) - VPS instances to run parallel OverlayFS sandboxes and benchmark latency past what my local machine can handle, alongside an initial exploratory budget to prototype Firecracker microVMs as a stronger, more secure isolation layer. I've already disclosed in my documentation the limitations of a privileged-container approach, and I want to start working on that gap soon.
Scaled compute for concurrent, multi-agent load testing ($1,500) - Running many parallel sandboxed containers at once, well past what a local machine can handle, would greatly accelerate my development and testing feedback loop.
Realistic multi-agent testing ($1,300) - Dev-tier Anthropic and OpenAI API access to run real agents end-to-end against the sandbox under actual multi-turn tool-calling requests. My current real tests are heavily limited by free-tier API request quotas.
AI-assisted development tooling ($700) - Upgrading from Cursor's free student trial to Cursor Pro+ or Claude Code, plus Claude Pro for architecture and planning work outside the editor to keep my shipping speed up.
Distribution ($500) - A domain and a proper screen-recording/demo setup. A demo has been my highest-converting piece of media for cold outreach, so I want to keep producing that.
Buffer ($500) - For whatever arises once I'm actually spending, rather than padding a line item to cover it.
Minimum ($3,500): Covers cloud infra/sandboxing and multi-provider API testing at a smaller scale, along with dev tooling. I'll be deferring the large concurrent-load infrastructure and distribution costs until more funding is available.
There is no revenue yet, and I don't plan to build any while this is still an unvalidated primitive. Rewind is open-source on PyPI and GitHub because keeping the core source open will drive real dev adoption. If it earns broad traction, I see monetization coming from a hosted or enterprise layer built on top of the open core. But I'd rather that be the second question, answered after the first one (does anyone need this?) is settled.
Currently building solo. The closest thing to a partnership is the open-source community itself. For example, the verification ledger in the current release came directly from a developer's proposal on Reddit after they looked at an earlier version, and I implemented and shipped it within days because the friction they described was real.
I designed, built, and shipped the first prototype of Rewind to PyPI in under a week, on free-tier tooling and a hefty budget of $0.
Before this, I built a research-visualization tool that converts research papers and complex protocols into queryable, interactive graph structures that can be explored with AI-assisted features. I spoke with multiple researchers from various R1 universities on the adoption of the tool, but it turned out to be a "vitamin" rather than a "painkiller", so I put it on pause (if a pivot comes up, however, I will consider resuming). But it helped me understand the gap between something technically impressive and something people actually need, which dramatically increased my shipping speed on Rewind.
My background includes quantitative research work in ML and economics, including a paper published with the Federal Reserve, under revision at the International Journal of Forecasting.
Technical risk: Firecracker microVMs may not cleanly replace the privileged-container model without giving up the near-instant checkpoint speed that is core to the product. But even a negative result is useful, and will allow me to state the actual boundary precisely instead of gesturing at a "known limitation".
Adoption risk: as of this application, Rewind has zero confirmed external users, only warm leads. My mitigation is direct, hands-on outreach to the warm leads I already have, offering to onboard early testers myself rather than just publishing docs and waiting.
Framework risk: the project is LangGraph-only as of now. If real friction turns out to live in other frameworks, the work may need to re-scope toward the framework real users are actually on. However, this wouldn't invalidate the underlying approach.
None. Rewind has been built entirely on free-tier tooling and $0 so far. I have three other pending applications that request funding for a narrower slice of these same costs:
1517 Medici Grant ($1,000)
Emergent Ventures ($4,500)
Merge Grant ($1,000)
I'll disclose any outcomes, and if one comes through before this is reviewed, I'll adjust this request to cover only the remaining, non-overlapping costs.