Getting Out Of The Way

When we started Dust, we made every decision for the model. You'd configure a data source, and on every message the system would retrieve the most relevant context and inject it into the prompt. Fixed amount. Fixed timing. No choices delegated to the model at all. It just received what we prepared, and generated a response.

It worked well. But the model had no say in any of it.

In 2024, we added a loop. The model could now decide which tools to call, in what order, and whether to keep going or stop. Driven by its own judgment, not a fixed sequence.

The natural approach was focused agents: one purpose, a small set of tools, a couple of steps. Models at the time weren't reliable enough to trust with more, so keeping scope narrow made sense.

Focused agents are still how most people use Dust today, and they work. The model follows instructions, uses the right tools, stays on task.

But as models improved, something new became possible alongside them. Agents that used to run for two or three steps could run for twenty. Given a wide enough set of tools, a capable model would figure out what to use without being told exactly. The overhead of maintaining a fleet of focused agents, each with its own conventions, each requiring updates when something changed underneath, started to feel less necessary.

Coding agents made the shift concrete. A single agent, used daily for almost everything, handling whatever came up without having to route tasks to a more specialized tool.

At Dust, the share of conversations going to our general agents went from 16% in August 2025 to over 40% today. People aren't abandoning focused agents, but they're discovering that a capable general one covers a lot of ground.

The right model isn't to configure everything from scratch for every use case. It's to start from something capable and extend it with what the context specifically requires.

That's what Skills are: getting out of the way of capability packaging.

Instead of building a new agent from scratch each time, you build a Skill: a reusable package of tools and instructions that any capable agent can read and decide to use. The model handles the loop, the reasoning, the defaults. You add what's specific to your domain.

Most of what we had built as "agents" turned out to be disguised Skills. Take Deep Dive: we packaged it as a dedicated agent that other agents could call as a sub-agent. That worked.

But turning it into a Skill means any agent can now access those same multi-agent research capabilities, composing them with other skills and tools. The same underlying capability becomes a lot more powerful when it's composable rather than siloed.

There's one more layer where we're still in the way: the infrastructure.

The tool list is fixed before the conversation starts. Every tool output (every search result, every API response) gets pasted into the context window. There's no working memory outside it; everything has to fit at all times. For complex, multi-step tasks, this means the context fills with intermediate results the model no longer needs, and performance degrades.

Those choices made sense when we made them. Today they're the main thing limiting what agents can do. Code execution is the path through. When the agent can write and run code, it stops having to route everything through the model: results land in files, operations compose naturally, and the context stays focused on what actually matters. The research on this is consistent, and the gains are large.

For Dust this means Sandboxes: each agent loop gets its own Linux environment, with common tools and a Dust CLI pre-installed. The agent can search, call tools, spawn sub-agents, write results to files, all from code. The context stays clean.

Every step has been the same: identify something we were deciding on behalf of the model, notice that the models had outgrown the need for us, and get out of the way.

We decided what to retrieve, then we let the model decide. We kept loops short and tools few, then we let them run longer with more. We built capabilities as standalone agents, then we made them composable. Now we're handing the model its own working environment.

Getting out of the way is a strategy. Not a concession, but a bet that the models will use the space well. So far, that bet has paid off every time.