For a long time, we tried to teach our agent through prompts.
Every failure meant another instruction, another caveat, another “make sure you…”. It was whack-a-mole. Fix one behavior in the prompt and another breaks. The prompt grows, the model follows some of it, and you never quite know which part.
So at Klarent, we stopped relying on the prompt. We started evolving the tools instead.
From prompt fixes to evolving the agent’s tools
Our agent works through a set of built-in functions. Every time the agent fails, the failure gets analyzed: what knowledge was missing? That knowledge goes into the function, not the prompt.
And no, we don’t do this by hand. We use AI to analyze the failures and rewrite the functions.
The lesson from a failure goes into the function, not the prompt.
Why scrolling is harder than it looks
Take scrolling. It sounds simple. It isn’t. Pages scroll inside nested containers, content loads as you move, elements sit just off-screen.
Instead of adding another line to the prompt each time the agent gets it wrong, the lesson goes into our scrolling function. The agent doesn’t need to know any of that, because the function already does.
Exosomatic Learning: knowledge that lives outside the model
The model’s weights never change. But the system gets smarter with every failure, because the knowledge lives in the code around the model, not inside it.
Karl Popper had a word for this. Humans, he argued, evolve exosomatically: outside the body, through the tools we build. A hammer extends the arm. A book extends memory.
We call our version Exosomatic Learning.
A prompt is a suggestion the model may or may not follow. A function is a guarantee. It’s memory by design, not memory by recall.
What Exosomatic Learning gives enterprise teams
This architecture unlocks benefits for enterprise that traditional fine-tuning or prompt engineering can’t touch.
- Customer-specific isolation. We can evolve functions based strictly on one customer’s unique edge cases, without cross-contaminating that hard-won knowledge across accounts.
- True data portability. Because the lessons are encoded in discrete functions rather than baked into a proprietary LLM’s weights, the knowledge belongs to the customer. If they leave, they can take it with them.
- Zero token bloat. Passing a 5,000-word prompt of rules on every API call is expensive and slow. Functions keep the context window clean, reducing latency and costs.
- Unit-testable reliability. You can’t write a reliable unit test for a massive prompt. You can write a unit test for a function. We replace probabilistic hope with deterministic code.
- Model agnosticism. When your agent’s knowledge lives in the surrounding code, swapping models becomes trivial. You aren’t locked into one vendor’s specific prompt quirks.
Post-training, without the training
It’s early days, but the idea scales. Over time, these functions become a record of everything the agent has ever gotten wrong, turned into things it now gets right.
Post-training, without the training.
The catch? It only captures what you can make concrete. But in agentic workflows, that covers a lot more ground than most teams realize.
