Your agent passed every eval you wrote for it. It handled the demo flawlessly. Then it went to production, met a refund request slightly unlike the ones it was tested on, and got it wrong. Next week it got the same kind of request wrong again, in the same way.
That is not a bug in your prompt. It is a generalization problem, and according to one of the people who built modern AI, it is the most fundamental problem the field has.
What Ilya Sutskever is worried about
In his November 2025 conversation with Dwarkesh Patel (transcript), Ilya Sutskever put it bluntly:
"These models somehow just generalize dramatically worse than people. It's a very fundamental thing."
His starting point is a puzzle anyone shipping agents will recognise. Models post remarkable scores on hard evals, yet the economic impact lags far behind what those scores promise. His example is from coding: you ask a model to fix a bug, it apologises, fixes it, and introduces a second bug. You point that out, and it brings the first one back. A system that can solve competition problems cannot hold a simple repair together.
Sutskever explains the gap with two students. One decides to become the best competitive programmer in the world and practises for 10,000 hours: every problem, every proof technique, every trick. The other practises for about 100 hours and also does very well. Which one has the better career? Almost certainly the second, because whatever they have generalizes. Today's models, he argues, are much more like the first student, only more so.
Part of the reason, in his view, is how models are trained after pre-training. Reinforcement learning environments are built by people, and people take inspiration from the evals. That can make models "a little too single-minded and narrowly focused": superb inside the distribution they were drilled on, brittle just outside it.
The contrast with people is the other half of his argument. A teenager has seen a tiny fraction of the data a model is trained on, yet learns new skills from a handful of attempts. Sutskever points at the human value function, the internal sense of whether things are going well or badly long before the final outcome arrives, as part of why. And he describes the system he would actually want to build not as a finished, all-knowing model but as something closer to an eager 15-year-old that learns on the job, where deployment itself involves a period of trial and error.
That last idea is the one that matters most for anyone running agents today.
What this looks like in production
An agent inherits every generalization weakness of the model underneath it, and then adds one of its own: it forgets. Each run starts from the same weights and the same prompt. Whatever the agent figured out yesterday, the hard way, is gone by the next task.
So the failure you saw on Tuesday is not a one-off. It is a standing property of the system. In our own measurements of agents running without any learning loop, 38% of failures were repeats of a failure the agent had already made on a similar task. Better prompts move the starting point. They do not stop the repetition, because nothing connects what happened in production back to what the agent does next.
Nobody outside the labs can fix how a model generalizes from its training data. But the agent's behaviour depends on more than the weights. It depends on what the agent carries into each task, and that is something we can change. Psychology has a useful map for it.
Three kinds of memory
Cognitive scientists separate long-term memory into a few systems. Endel Tulving drew the line between episodic and semantic memory in the 1970s, and procedural memory, the memory of how to do things, sits alongside them. Each one has a direct counterpart in an agent, and each one fails differently when it is missing.
Episodic memory: what happened
Episodic memory is the record of specific experiences: this conversation, that run, the time the deploy failed on a Friday. For an agent it is the trace: the inputs, every tool call, every intermediate decision and the outcome.
Most teams already have this, in an observability stack. The trouble is that episodic memory on its own is just a log. A pile of transcripts does not make the next run better unless something reads them, judges them and pulls the right lesson out at the right moment. An agent that can replay every past episode but cannot tell which ones matter is the first student again, memorising rather than learning.
In Pulsar, every thread keeps its full history, so a conversation can be picked up where it stopped. That is episodic memory working as continuity. On its own it is not yet learning.
Semantic memory: what is true
Semantic memory is knowledge pulled free of the episode it came from. You know Paris is the capital of France without remembering where you learned it. For an agent, this is the layer of facts, preferences and conventions: the team writes in British English, invoices go out on the first working day of the month, the customer's contract renews in March.
This is where most agent "memory" products stop, and it does real work. Without it, every session begins by re-asking things the agent has been told a dozen times. Pulsar's agent memory stores these as durable facts at the right scope (you, a project, the whole organization) and finds them again with hybrid search, so a question about "test runners" still finds the note that says the team prefers Vitest.
But semantic memory answers "what is true?", not "what works?". Knowing the refund policy is not the same as knowing that refunds fail unless you check settlement status first. That second kind of knowledge lives somewhere else.
Procedural memory: how to do it
Procedural memory is skill: how to ride a bike, how to run a close, how to handle a refund without getting burned. It is the hardest memory to write down and the one that most separates an expert from a novice. It is also exactly what Sutskever's second student has and the first one lacks.
Agents get procedural memory in two ways.
The first is written down ahead of time. In Pulsar that is a skill: a playbook for how your team does a piece of work, which the agent loads when the task calls for it. Skill Studio exists to make writing these easy, because a good skill turns a one-off success into a repeatable one.
The second is learned at runtime, from experience, and it is the part that speaks most directly to the generalization gap. This is what we built agentRTX for.
Experience as procedural memory
The idea behind agentRTX is that there are two moments to improve an agent. Compile-time optimization (prompt engineering, DSPy) prepares the agent for its first attempt, before deployment. Runtime experience makes sure every attempt after the first learns from the ones before. Without it, agents stay perpetual beginners, no matter how many times they have done the same kind of task.
The loop has three steps:
- Capture traces. Observability tools such as LangSmith, Langfuse or OpenTelemetry already record what the agent saw, what it did and what happened. That is the episodic layer.
- Grade outcomes. Evals decide whether a run succeeded: human review, an LLM judge, or a signal from your own systems, like a refund that bounced.
- Learn from experience. agentRTX turns graded runs into short, reusable lessons and surfaces the relevant ones before the agent starts a similar task. The agent that struggled with refunds last month now knows to check settlement status before processing one.
The important detail is how those lessons are chosen. Ordinary retrieval ranks memories by how similar they look to the task. Similar is not the same as useful: the note that would have saved a refund often reads nothing like the refund request. agentRTX ranks lessons by utility instead, learning from outcomes which memories actually improved task success and which ones just looked relevant. In Sutskever's terms, it is a small, practical value function for what the agent remembers: a running sense of what tends to lead somewhere good.
The results are why we think this matters. On TAU-Bench, the standard test of multi-turn customer-service agents, strong static frontier models top out around 56% success on the first attempt. With runtime experience, our agents reached 80% using an open-weight model at a fraction of the cost per run, and over six months repeated failures fell from 38% to 12%. The underlying model did not get better at generalizing. The agent stopped making the same mistake twice.
Learning on the job
None of this solves the research problem Sutskever describes. A model that truly generalizes like a person will need new ideas in how models are trained, and that work belongs to the labs.
But his picture of the system he would want, one that keeps learning after it is deployed, describes a design you can adopt today. Give your agent all three kinds of memory: episodic, so nothing that happened is lost; semantic, so it stops re-asking what it has been told; and procedural, so the skills you write and the experience it gathers make every run better than the last.
Your agent may never generalize like the second student. It can still learn like one.
Want to see runtime experience on your own agents? Book a call with us.
