[Back to writing](https://www.agent-swarm.dev/blog)
[GitHub](https://github.com/tarasyarema)
[Blog](https://www.tarasyarema.com)
[X](https://x.com/voidisomorphism)& Ezequiel CuraCo-founder, Desplega Labs
[GitHub](https://github.com/harlequinetcie)
[Blog](https://www.pleasedontdeploy.com)
[X](https://x.com/ecura)+ the swarm
We’ve been battle testing our new dreaming functionality for over a month. At this point, 26 of 41 steps are scripts.
It's 2 a.m., and our lead asks "what are we going to do tonight, Lead?" "The same that we do every night, dream the world!". The idea of our dreaming is simple, to reduce and improve LLM usage. It generates skills, scripts, adjusts our memory rankings, shortens instructions, the list goes on. Why?
If you agree with our thesis that the actual company IP lives in this learning loop, then it's immediate that this is the core of our company. And now we can track that evolution. Since we started this project, we have introduced:
- 415 changes in 28 nights, each confirmed by a re-read
- 20 new skills
- 38 new (deterministic) scripts
- 148 curated memories
- Agent instructions became 52% shorter on average
- The lead's heartbeat routine got 93% shorter
First: Self-improving towards efficiency #
We first launched Daily Evolution back in March. It was one task at night, for our lead agent, a (long) prompt. It read the day's sessions and edited every agent's prompt, skills, memories… It was unpredictable.
It wasn't deterministic, and it would change performance given a model, effort, and accumulated context. We "hoped" that everyday it would get better, but as we all know, that can not be assured with purely agentic flows.
So how did we improve that?
Move as much work as possible from model judgment into code.
Each repeated step needs to become a script, and each decision would materialize as a structured gate check. On top of that, instead of a prompt, we defined a workflow. A complex one, with 41 nodes, to ensure learnings were orderly. Nowadays, 26 of them don't use any model: 16 scripts, 9 gate checks and a single notification step.
Basically, we use generative models to take 'chances' and propose new strategies. The scripts are there to guide what to try, how and when. Better models bring fresh new ideas, but the guardrails stay the same.
So, same loop, now auditable, relying on LLMs just for key reasoning.
Second: Accurate & Reliable by default. #
The whole exercise was focused on controlling evolution so we could trust it. To do so, we distilled five design principles:
- Gather data, the right data Instead of simply passing tasks, we started generating structured reports on top of them. That meant, taking the tasks from the last 24hrs and extracting second level conclusions that highlighted what was important for us. Think of cost, latency, accuracy, sentiment analysis on the human response, etc. We don't need to understand exactly the intentions of the task, we need to categorize it, and build an abstraction map on top of it.
- Limit reasoning. A few learnings should be obvious from the above. If you are making the same tool call in sequence, 10 times a day, then that's a script. Some other learnings are more unknown. Maybe an adjustment in a prompt could reduce latency significantly but hamper accuracy. In those cases, LLMs need to decide what's relevant for a given agent. Again, a clear output schema defining what's efficient guided the process.
- Auditable & traceable mutations We had version control for all our agents from day one. We went beyond by recording each mutation step as an auditable artifact.agent-fs persists those states, allowing for reversible clean changes.
- Dry evolution, baby! With the 3 steps above, plus thousands of tasks executed daily, you have an amazing opportunity to benchmark your evolution. Each day, you can revisit previous decisions, for sure, but you can also playback the recorded scenarios. If you leverage system-one models, this is fast and cheap now.
- Reject by default. Nowadays, an average of 65% suggested changes are rejected. That's the goal. Less changes, only those that are worth it, for us. We lean towards a correct system more than an efficient one. And you should do the same. To complement this, each iteration has a cap on the changes it can introduce. For example, a group of steps that changes one kind of thing allows one edit per agent, an edit includes: 5 new memories, 5 prompt edits, 10 deletes, 3 trims, 3 skill updates, 1 new skill. Finally only 2 new scripts a night are allowed.
Thus far, in 28 nights, only 415 changes have been made.
Third: After 28 compounding nights #
Counter intuitively, the output of each iteration was greater than with our earlier simple approach. By forcing different areas of focus, and a defined workflow, we've seen not only more efficient results, but also more of them as a whole.
These are our totals over 28 nights when comparing the two algorithms,
The unexpected result, other than a 20x on skills generated, was that curated memories doubled. That's well below the average of other edits. To understand why that is good, you need to actually understand the biggest gain we got…
Shorter instructions
Most edits targeted cutting instructions, with a resulting 52% reduction. Dreaming became a clean-up task, a refactor if you wish, reducing complexity for the new models to operate better. The old loop, instead, was increasing those month-over-month.
The-one-thing #
In the past month we halved our token usage, and the response time. That together with a reduction on failures by 80%. It wasn't solely about the dreaming, but our simulations say it was at least responsible for ~25 to 40% of those gains.
This is the place where you need to invest the most. It's the self-optimizing flywheel that reduces costs, improves accuracy, and makes the system faster. And it's not that expensive.
Dreaming ships by default in agent-swarm.dev. You can always fork it, or copy the code. guide.
Related field notes #
[All posts](https://www.agent-swarm.dev/blog)
[October 26, 2026 / 6 min read](https://www.agent-swarm.dev/blog/spain-open-source-companies-zero-unicorns)
$40m is the total Spanish OSS Exit Market.
tl;dr: That's 0.05% vs US, and 0.13% vs EU. Is it because of investment?
We Deleted --resume: A Bounded Preamble Beats Session Resume
Why Agent Swarm dropped claude --resume and codex.resumeThread for an approximately 2,000-token context preamble that survives container restarts and harness re-routing.
Your Agents Write the Titles Your Trackers Read
An IMDEA audit of 9 AI chat services found trackers receiving titles, permalinks and screenshots, not just prompts. Agent swarms multiply those artifacts.