Over the last few months, we've spent a lot of time building AI agents into Runnit.
Not one or two of them. Lots of them.
Each had a specific responsibility. One focused on planning, another on research, another on scheduling, another on writing. They all had carefully crafted prompts, distinct behaviours and their own area of expertise.
At the time, it felt like the right architecture.
The original LLMs we were building on (which seemed like only yesterday) had much smaller context windows (64k-128k), so breaking work into specialised agents wasn't just cleaner, it was necessary to produce even semi-accurate results. Each agent only needed to understand one problem, which meant it could use its available context more effectively.
As the models improved though, we slowly realised we were still designing around yesterday's limitations.
The more we tested newer models with larger contexts, the more we found they could naturally switch between different kinds of work without needing to become a completely different assistant. They could plan, write, research and reason within the same conversation, provided they had the right information available at the right time.
That forced us to ask a simple question.
Do these really need to be separate agents?
In the end, our answer was no. So we removed them.
Instead of maintaining a growing collection of specialised agents, we rebuilt the architecture around a single intelligence (introducing Ru) that loads capabilities when it needs them.
Research isn't an agent.
Scheduling isn't an agent.
Writing isn't an agent.
They're capabilities and directives. They're pieces of expertise that can be loaded for a task and then unloaded again when the work is finished.
The change sounds small, but it simplified almost everything.
There's one consistent understanding of your business. One conversation. One memory. One place for organisational knowledge to live.
When speed matters, that same intelligence can simply create parallel instances of itself, each loading the directives required for its own piece of work before bringing everything back together. From the outside it still works in parallel, but underneath it's the same intelligence solving different parts of the problem.
We also found ourselves deleting a surprising amount of complexity. We no longer had to maintain dozens of individual prompts, coordinate hand-offs between separate agents, or worry about different agents gradually drifting apart as they evolved.
None of this means specialised agents are obsolete. There are still good reasons to isolate work, use different models or separate permissions.
But I do think many of us are carrying architectural decisions that were made for models that no longer exist.
If we were starting Runnit again today, I don't think we'd begin by asking, "What agents should we build?"
I'd start with a different question.
"What capabilities does a single intelligence need?"
Sometimes progress isn't adding another layer.
Sometimes it's realising you don't need it anymore.