Voidleap Code

Today we are dropping Voidleap Code 1.0, free, for everyone. It is a full agentic coding environment: it runs on your machine, and requests go straight to the providers you already pay for. The other half is how you use it: the harness and scaffolding around the model. No provider has the best model for every task. Mixing them is not a cost trick, it gets you a better result.

You have probably thought it already: not another AI coding tool. We think the same every time one ships. And still, there is a void where the good tools should be.

Look inside almost any of them and you find the same thing: a wrapper. A wrapper never owns the loop. The harness is borrowed, and the other half of the equation stays out of reach.

A year ago the models were already good enough. The tools around them were not. The one tool worth using lived in a terminal. That locked you to one agent, one task at a time, blind to most of what it did. We wanted the opposite: many agents, one view, nothing hidden.

Voidleap has been built inside Voidleap since January. Somewhere along the way, the old tools stopped being an option.

Many agents: Voidleap Code is a full agentic IDE where you run as many threads and agents as the work needs, with every tool built in. If you need to edit something manually, the editor is right there.

One view: every provider tool has its own agent and skill setup, and when you switch, you start over. In Voidleap you set up once, and it works with every model. Swap models mid-conversation and keep the whole thread. Mixing models is not a feature we bolted on; it is the reason the harness exists.

Nothing hidden: you see the context every agent holds, and you can edit it. You see what each subagent did, which tools it ran, where the tokens went.

That only works when you own the loop. We do.

There are things 1.0 does not do. No themes. No translations. And fewer providers than you might expect, because we ship a provider when it works well, not when it fills a logo wall.

The sore spot is Claude subscriptions. They are not supported, because Anthropic has not decided what third-party harnesses may do. So, Anthropic: let's talk. We built proper cache handling, context management, and runaway-loop prevention. Run a certified-harness pilot with us, and give your customers a choice of tooling without touching your margins.

And the honest gap: what we lack most is not features, it is users. We are bootstrapped, with no marketing budget. If Voidleap earns a place in your work, tell a friend. That is the whole growth plan.

The boring facts:

• Free. We sell no inference and make nothing on your tokens.

• macOS and Windows.

• Bring your provider subscriptions, API keys, or local models.

• Runs on your machine. Requests go straight to your providers, and we never see what you send or receive.

• Closed source. Nobody funds us but our future customers.

The rest, fine print included, you will find here on voidleap.com.

We are not done building. Tell us what you need. Enough voices move it up our list.

Conny Wallström & Daniel Nilebäck
Co-founders, Voidleap

Following up on last post, I thought I'd share a bit more on why we created Voidleap Code. We experienced basically three levels of hell which triggered us to start this journey and build something better.

1. Observability hell

Most tools give you a limited view of agent actions. So when you try to understand what happened and why, you're basically looking on a black box. Adding to that, code diffs wasn't really easily consumed, rather hidden away. This first hell really was the first block of owning and controlling your agents and the outcome.

2. Configuration hell

Then when you actually find out how you want to configure your workflow, agents or skills - you enter the second hell where you need to control all markdowns for agents. You have different versions stored in each repository. Just finding them is troublesome enough. Then getting an overview of their configuration, easily editing, or just re-use them... It was nearly impossible to own the workflow.

3. Terminal hell

Scaling up to multiple running agents in parallel didn't work either. Each thread/session was a new terminal window, and we tend to keep them open even after they was completed, because we might need to continue from that context in a new turn. The solutions to organize terminals exists, but it wasn't enough. It wasn't easy enough to start work in a thread, pause it for hours/days and resurface it again.

So we built Voidleap Code.

Deep observability over black box magic.
Visual scaffolding compatible with existing markdown files.
Agentic development environment instead of terminals.

Was built in stealth. Now we're on the go to market journey.

Some coding tools aren’t built to make you a better developer. They are built to sell more inference…

Your output becomes better when you control the build. We built an observable and configurable tool so you can be in control.

Context management is key. Prune your context to avoid bloat and drift. Observe the agents in real-time, and fine tune your agentic scaffolding to reduce turns and spend less tokens.

To build this, we had to start with the foundation. We built our own harness, because it's impossible to build proper context management and deep observability without it.

And we built Voidleap Code in stealth. We didn’t want to launch an early beta – we wanted to launch a capable tool on a solid foundation. Now it’s ready, and we’re looking for early adopters that enjoy battle-testing, and that are happy to share direct feedback to shape the build.

BYOK, local-first, privacy, performance... And guardrails that actually works.