Craft Anything Rebuilds Software Under a Clean-Room Contract
The pure-Rust engine studies any target, hands it to your coding agent, and proves every step with a hashed evidence ledger.
- Craft Anything's headline feature is not cloning, it is the clean-room contract that governs how a rebuild is allowed to happen.
- The clean-room and deep modes are mutually exclusive runtime switches that map onto a real legal distinction between reimplementation and copying.
- Every tool call lands in a hashed evidence ledger, so a generated report cannot contain an unsourced claim.
- The engine sits above your coding agent, running it as a subprocess and wiring it back to its own MCP server rather than replacing it.
The Clean Room Is Not a Slogan
Most people read the launch pitch as a cloning tool. Point it at a website, an app, or a game, and it builds you another one. That framing is the least interesting true thing about the project.
The genuinely engineered surface is the opposite: the compliance regime wrapped around the rebuild. Craft Anything exposes it as a switch. Two flags, --clean-room and --deep, are mutually exclusive. In clean room, nothing inside a target is read. Tools that would disassemble a binary, parse a file, or open a page's source simply refuse. In deep mode, those tools activate and may read a target's code, files, and page source.
That distinction is not a feature toggle. Clean-room reimplementation is a specific legal idea: you may study a thing's observable behavior and build your own version of it, but you may not copy what is inside it. Craft Anything turns that distinction into a runtime mode the user has to choose, and it defaults to the safe one.
Craft Anything works from what you can see: pictures you add, the website as a visitor sees it (screenshots, visible text, measured layout, colours, fonts and spacing, menus opened) and, when you allow it, a picture of the app's window.
Read that again with the flag in mind. The clean-room mode is not a disclaimer bolted onto a cloning engine. It is the default state of the engine, and deep mode is the opt-in exception for private work. The guardrail is the product.
Study, Build, Check, Ready
Once you accept that the contract is the point, the workflow stops looking like a magic trick and starts looking like a governed process. Four stages, run in order.
Study inspects the target with real tools: a disassembler, a format parser, a JavaScript analyzer, a page capture at multiple widths, and for games, the game's own self-test. Build hands those findings to a coding agent in whatever stack you name. Check compares the build against the original and opens refinement rounds. Ready produces the report.
Two numbers keep the loop honest. The refinement loop is bounded by --rounds, which defaults to two. And it stops early when the build clears a good_enough threshold pulled from settings. Both are cost and time controls written into the product, not afterthoughts. An asset budget does the same for generated images and models.
Every Claim Has a Receipt
The mechanism that makes the contract real is the evidence ledger. Every tool call produces an entry. The target itself is tied to a SHA-256, so evidence is anchored to a specific file, not a vague memory of one. When a run finishes, the report ships with an evidence-ledger appendix attached.
The consequence is sharp: a generated report cannot contain an unsourced claim. Each statement in the output traces back to a tool call and a hash. That is what separates a clean-room mode that is aspirational from one that is enforceable. Without the ledger, the flag would be a promise. With it, the flag has a paper trail.
Every build is compared with the original (pages at three screen widths, a game's own self-test, an app's runs) and refined until it's close.
The error model follows the same instinct. Failures return a ToolError that carries a .with_remediation(...) hint, so a broken step tells you what to do next instead of just stopping.
One Registry, Three Faces
The engine ships with 284 tools, and they are defined once. That single registry is exposed three ways: as CLI subcommands, as MCP tools for agents, and as in-app UI actions behind Ctrl or Cmd plus K.
The CLI does not hand-write a subcommand for each tool. It uses clap's external subcommand hook, so any unrecognised subcommand routes straight to the registry.
#[command(external_subcommand)]
Tool(Vec<String>),
// usage:
// craft-anything-cli <tool> [path] [--key value] [--json '{..}' | @file.json | -]
The payoff is that adding a tool makes it instantly available to a human at a terminal and to an agent over MCP at the same time. That is the agent-ready thesis made concrete: there is no separate agent surface to maintain, because the agent surface and the human surface are the same object.
It Does Not Replace Your Agent
This is the part that reframes the whole category. Craft Anything's backend model lists five kinds: hosted APIs, OpenAI-compatible local servers, and AgentCli. That last one runs another coding agent as a subprocess (Claude Code, Codex, Gemini CLI, OpenCode, Hermes) and connects it back to Craft Anything's own MCP server. The product sits above your agent rather than competing with it.
Two smaller patterns show how seriously the human-in-the-loop idea is taken. A hidden BuilderNotes subcommand lets a person steer a running agent by writing notes into a folder that the agent's hook system reads after each tool call. And an inbox mode posts questions and approval requests to a folder, so a headless agent and the human answering it communicate through the filesystem without a live channel.
Then the safety asymmetry. In unattended mode, questions are answered with a default, but approvals are refused, not assumed. The code models one rule structurally: nothing that changes a device or runs code happens without a person. Questions get a guess. Approvals get a no.
Where Craft Anything Fits
Craft Anything's nearest neighbors each solve part of the problem. The table separates what each one inspects, produces, and whether it leaves a trail.
| Project | What it inspects | What it produces | Workflow shape | Agent integration | Audit trail |
|---|---|---|---|---|---|
| Craft Anything | Websites, apps, games, files | A checked rebuild | Study, build, check loop | Runs your coding agent as a subprocess | Hashed evidence ledger |
| screenshot-to-code | Screenshots and URLs | Frontend code | One-shot generation | None | None |
| Ghidra | Binaries | Analysis and decompilation | Analyst-driven | None | None |
| radare2 | Binaries | Analysis | Analyst-driven | None | None |
| Cutter | Binaries | Analysis, GUI | Analyst-driven | None | None |
| OpenHands | Code repositories | A working project | Agent loop | Is the agent | None |
| browser-use | Websites | Automated actions | Agent loop | Is the agent | None |
| Claude Code (adjacent) | Your codebase | A working project | Agent loop | Is the agent | None |
The gap Craft Anything claims is the loop plus the ledger. The reverse-engineering suites inspect deeply but do not rebuild and compare. The coding agents build but do not study a target or leave a receipt. The screenshot tools do one pass and stop.
The Debate It Walked Into
A tool that rebuilds games and apps was always going to land in a fight. The documented flashpoint is game recreation. Reporting on the launch notes that Craft Anything adds instructions to Claude Code rather than removing Anthropic's, so some recreation requests may be refused by the model underneath. That is a report about the tension, not a measure of how often it happens.
We believe that you should have the final say in what you do with your property, and not @AnthropicAI. That's why we're dropping Craft Anything!
Using Claude to infringe IP is against our usage policy.
The independent fact-check on the project draws the line the tool itself draws: clean-room rebuilding is not the same as copying proprietary code, the default mode is clean room, and deep mode exists for private use. None of that settles whether any given rebuild is legal. It only establishes which mode the tool is in when you do it, and that the default is the conservative one.
The origin is brief. Developer Brandon Thomas, known as @echelon, builds it alongside a sibling project called ArtCraft, with a shared Discord. The repo is dual-licensed MIT or Apache-2.0, and its READMEs ship in English, Japanese, Chinese, and Korean. That last detail is a distribution signal as much as a technical one. But the product is the story here, not the person.
Strip away the launch headline and what is left is a reverse-engineering workbench that behaves like a regulated process. A mode switch the user must choose. A ledger that anchors every claim to a hash. An approval path that refuses to guess. The rebuild is the demo. The contract is the design.





