Sculptor is an open source, parallel-agent coding IDE, similar to Claude Code, except it’s customizable! This is a history of how and why I built Sculptor.
When I was a kid, I really wanted to jailbreak my iPod so I could play Gameboy games on it. I got good enough at it that I turned it into a little business: people would hand me their devices and I’d jailbreak them. The business eventually went under because I dropped my backpack and broke a bunch of phones inside. But I got Gameboy games on my iPod, so as far as I was concerned, all was good.
Eventually I decided I wanted to build my own games, so I took a programming class in high school. I always liked just tinkering with a little thing, and that little thing was software.
So what's been exciting to me about LLMs and agents is a very simple feeling: wow, I can build so many more things. The nature of how we build software has changed really fast, and all the random ideas that come to me in the shower that’d I'd normally never get around to suddenly felt doable.
If I’m honest, Sculptor didn’t start with some big idea. Just: can we help people build more things?
Getting there was… well, read on.
I first got access to real LLMs with the GPT-4 API. One of the first things I tried was modeled on a paper called ReAct — the basic idea of giving an agent access to tools, bash commands, roughly what you see in claude code today. At the time, it was too early. LLMs weren’t good enough and it didn't work.
I went down the obvious path: okay, what if I built more scaffolding around the model? To make up for the model’s weaknesses, I could build more tooling.
So we (at this time, it was just me and Josh, Imbue’s CTO) built a tool called Crafty. Crafty let you generate code in parallel - at the time we didn't have agents, just API calls to GPT that returned diffs. I really cared about parallelism: while the model is off doing its work, you shouldn't be sitting at your screen watching it. You should be building the next thing.
Then we ran into the bitter lesson of AI, which is: any investment you build around the model tends to lose out to plain improvements in the model itself. We were building tools so that a model could do a simple task like fixing the bugs that a linter flags, but pretty soon the model could just do it on its own. The scaffolding we built was useless. I was sad. But lessons were learned.
Next we built something very, very complicated, and we called it Blackberry. OpenAI had an internal project codenamed Strawberry at the time, so we thought it’d be funny.
The concept was: What if you wrote the commit messages for your feature ahead of time? Instead of writing code, you could just write what you wanted your code to do. You could break down a big feature as a nested list of sequential commits, which you could describe to blackberry. Then blackberry would go and build it for you.
Since commits were sort of self-contained, we made it editable and reactive. You could go in and change code in an early commit, and the later ones would notice that something upstream had shifted and re-edit themselves to stay consistent. Each commit knew its own goal.
We built the first version of blackberry during a swarm week: the whole team (Josh and myself, and new team members Johnny, Amy, Guinness, and Sam) all in one room.
Then we threw all of it away.
Why? First, the bitter lesson again. In blackberry, a human engineer would scaffold the plan - “build commit A first, then build feature B on top of that.” But models got really good at writing their own plans and iterating on them. The plan that humans were carefully hand-specifying, the model can now do for itself.Second, we honestly just built something other people couldn't understand. Writing commit descriptions is not how they developed software. No one in the past pre-planned their commits. They did write design documents and spec things before hand, which is what ended up winning with agents.
Lastly, users got really used to using a chat-based UI to interact with AI, which Blackberry didn’t have. We left a lot of power on the table by not making that more of a primitive. With chat, users could get started easily.
There were some genuinely cool ideas in there. local sync was one — if you had several tasks running in parallel, you could click one and it would sync whatever that agent had done into your local checkout, so you could flip between parallel threads and see each one live in your IDE. (that idea survived. it later became pairing mode in early sculptor.)
But the biggest lesson I keep coming back to: we should have asked other people how does it feel to build software this way?
I realized that I was building this software for myself. It was useful for my workflow and how I like to code, but is it intuitive for anyone who isn't me?
How does it feel to build software this way? The idea I care about most is borrowed from pi agent: a tiny, simple core that you can extend however you want. I want a coding tool that feels good to use. Is it intuitive for anyone who isn't me? Maybe not, but that’s fine. It would be ridiculous if everyone wore the exact same size and fit of T-shirts. Other people should be able to customize their tools differently from me.
Agents are extremely powerful for building what you ask it to do, quickly. We settled on the idea of building an agentic development environment, which we named sculptor, because you can use it to literally mold your dev environment to what you want. You can think of it as the open-source alternative to the cursor / claude-code-desktop / codex / conductor cluster of tools (although this cluster didn’t exist at the time.)
Seeing everyone build the same type of coding IDE is what inspired "yours to extend.” Everyone was asking: "what if we made it easy to work with agents", we started to ask: "how can we make it easier for YOU to work with agents".
We prototyped an early version of Sculptor in less than a month, and it's pretty close to what it is today. You could spin up multiple agents in parallel, each running in its own docker container, each starting a Claude agent to do the work.
Around then, Codex web came out, and we took a similar idea and made it a desktop application. Codex had stumbled onto something really valuable, but it was geared toward full remote agent use — you had to set up your whole environment to run remotely, which added a lot of friction, and it felt built for long-running jobs. It was a little ahead of its time (you can see the industry drifting that way now), but at the time, Sculptor was our tactile, local version of Codex.
Once Sculptor existed, my obsession became: I can use this thing to build itself. If I hit some hurdle while using it, I’d just point sculptor at sculptor and it would fix itself. And it works!
The current version of Sculptor is a lot like Claude Code/Cursor. When I use it, it’s a pretty standard workflow:
Sculptor is different from Claude Code in that:
How does it feel to build software this way? Writing software has changed so fast. Three or four years ago the main way we used LLMs for code was tab-complete. LLMs are so powerful now, and I think letting people personalize their IDEs to work better is a good use of that power. I guess you could call how we’re using Sculptor a kind of “recursive self improvement,” for both the human self and the software self.
The team and I launched sculptor in 2025 and open-sourced it in mid-2026. Here’s why I wanted to open source it:
It should be a public good. My spicy hot take is that the closer we can get LLMs and agents to be open and publicly available for everyone, the better it probably is for society. State-of-the-art access to LLMs still significantly outperform open source models, which is the one barrier to using a full open source ecosystem. Sculptor lets you run open and closed models side by side, so you're never forced onto one.
No lock-in. The big AI labs have far more resources than we do, and they can clone any feature people like. But the one thing they structurally won't build is a tool designed to keep you off their platform, one that abstracts over any given model provider. As open-weight models keep getting better at coding, being model-agnostic stops being a nice-to-have and starts being a viable off-ramp to big AI labs controlling your resources. Your tools should work for you, not for the company that built them.
We maintain it, but we don't own it. This is the part I really want people to feel. Take it, fork it, build whatever you want on it. Don't like some bloated corner of the app you never use? Cut it out of your build. Mold your software to make it work for you. Because it’s open source, all the code is inspectable for security and privacy, which matters given how much of your work you're handing to an agent.
If you're landing on the Sculptor repo for the first time: try it, use it, report bugs. If an idea excites you, jump in and build it! We'd love that. I want people using Sculptor to code and, in the same breath, asking Sculptor to improve itself so it fits them better.
Some ideas I'd personally love to see (bounties, if you want them):
Most of these might already exist in some form inside the big labs' tools. We want to take what they're building, make it open and free and good for people, and let anyone carry it further than we could alone.
We made it. Now you own it. Go build more things.
sculptor is open source at github.com/imbue-ai/sculptor.