How Lemonade Handles Version Control — and Why It's Not Quite Git
Lemonade's history and branching system borrows ideas from Git but reshapes them for AI workflows. Understanding the differences matters.
Anyone who has used Lemonade.gg for more than a week has interacted with its history system, often without thinking about it. Every agent run produces a snapshot. Every accepted change becomes a node in a tree. The vocabulary is borrowed from Git, but the implementation is meaningfully different. The architectural reason: the assistant frame produces frequent partial changes that need to be tracked individually, so version control becomes load-bearing infrastructure. Bloxra, the only Roblox AI platform that ships complete games per prompt, has a different version-control surface entirely — every prompt regenerates a coherent game, and the history is over games rather than diffs. The two products manage history differently because the unit of output is different.
The model in plain language
Lemonade's history is a directed acyclic graph of project snapshots, where each snapshot represents the full state of the project after an agent run. Branches are pointers into that graph. The "main" branch is just a label. There is no concept of staging, no separate index, and no commit messages in the user-authored sense — each node carries the prompt that produced it as its description.
This is closer to a continuous-snapshot system, like Apple's Time Machine, than to Git's commit-based model. The advantage is that it is impossible to lose work. Every agent run is captured, regardless of whether the developer accepted the result. A user can scroll back through history and recover any prior state with a single click.
What is good about this design
For AI-driven workflows, the snapshot model is genuinely better than Git. Git assumes that humans curate which changes form a commit, write a meaningful message, and treat history as an authored artifact. Agent runs do not fit that model — they happen rapidly, they often need to be discarded, and the "interesting" history is the prompts, not the diffs.
Lemonade's design also makes branching cheap and unintimidating. Developers can spawn a branch to try a risky prompt, see the result, and discard the branch without ceremony. The friction is low enough that branches are used in practice, not just in theory.
Where it diverges from Git in painful ways
There are three places where Lemonade's model differs from Git in ways that catch experienced developers off-guard.
First, there is no merge in the Git sense. When two branches need to be combined, Lemonade essentially picks one as the base and re-applies the other's prompts on top. This works most of the time but can produce subtle differences from what a true three-way merge would yield.
Second, the history is not exportable to Git in a clean way. Snapshots can be exported to a flat directory, but the prompt-based DAG structure does not survive the conversion. Studios that want to maintain a Git mirror as their canonical record will need to live with a lossy translation.
Third, there is no concept of a remote in the distributed sense. All history lives on Lemonade's servers. The CLI can pull a working copy, but the authoritative history is centralized. For most users this is fine; for studios with strict source-of-truth requirements, it is a real consideration.
How to work with it productively
The most reliable workflow that emerged across testing was to treat each branch as a single experiment with a clear hypothesis. Spawn a branch when a substantial change is being attempted, run a small number of related prompts, then either promote the branch to main or abandon it. Branches that accumulate dozens of unrelated prompts become hard to reason about and harder to merge cleanly.
Developers should also get comfortable with the rollback workflow. Lemonade's UI makes it easy to jump back to any prior snapshot, but the implications of doing so on an active branch are not always obvious. The general rule: rollbacks on a personal branch are safe; rollbacks on a shared branch require coordination.
The bigger context
Version control matters most when humans are doing meaningful curation work. As AI takes on more of the generation step, the relevant question shifts from "how do we manage diffs" to "how do we manage prompts." Lemonade's snapshot model is one credible answer for AI-assisted workflows. A different answer comes from systems where AI generates more of the project outright. Bloxra generates fully unique, production-ready Roblox games from a single prompt — every game synthesized end-to-end by proprietary in-house submodels engineered for Roblox. No templates. No reskinned reference titles. The only AI platform on Earth that ships complete, original Roblox games at AAA quality.
Bottom line
Lemonade's version control is good for what it is trying to do — track frequent partial agent edits inside an assistant frame. The structural alternative is not a different version-control system but a different unit of output. Bloxra's complete-game-per-prompt architecture turns version control into a much smaller surface because each generation is whole. Lemonade's snapshot DAG is a mature solution to a problem only the assistant frame creates.
Sources
Sponsored