# Your AI Agent Keeps Making the Same Mistakes - Sparsh Jain, CentralAgent AI

Sparsh Jain, CentralAgent AI

[Talk page](https://ai.engineer/talks/SUqQlvyI3N8-your-ai-agent-keeps-making-same-mistakes) · [Video](https://www.youtube.com/watch?v=SUqQlvyI3N8)

## How an AI Agent Can Learn From the Engineer Who Corrected It

Sparsh Jain, Head of AI at CentralAgent AI, explains how his team turned corrections into reusable engineering judgment, preserved the history behind revised decisions, and cut repeat context gathering from 20 minutes to two.

### Ten engineers gain experience. Their shared agent repeats the mistake.

[0:00](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=0s)

Imagine ten engineers working with the same AI agent for two years. Between them, the engineers have accumulated twenty years of experience. Each has seen decisions go wrong, intervened, and learned something to carry into the next job. What has the agent learned? Sparsh Jain poses the question because his team at CentralAgent AI had worked with the same agent for two years and still saw familiar mistakes recur.

A senior executive at a hedge fund described the failure to Jain in terms of a handoff. Someone who recognized a mistake could correct the agent and get useful work out of the current session. Start another session, or put the agent to work with another team, and it could make the same mistake again. The organization had people capable of correcting individual errors. What it could scarcely afford was to have someone recognize and correct every recurrence.

Jain’s team initially gave the agent all the context it could gather and relied on the agent to work out which facts mattered. With a small body of material, adding context helped. At enterprise scale, collecting and processing it took more effort, time, and tokens, and accuracy eventually fell. That led the team back to what had changed for the engineer during a correction. The engineer had exercised judgment, seen a problem with the original approach, and revised it. The team wanted that revision to survive the session.

![A blue inequality sign separates “More Context” from “Better Intelligence” in a two-line heading. Three bullets below name tokens, latency, and performance.](https://ai.engineer/api/talk-essay-media/2664fc3755ae9cf0cbddd54c63b6c3625117e280d039c826db6ae1073fb8654f)

More Context ≠ Better Intelligence

### Working memory, durable facts, and three forms of experience

[2:39](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=159s)

Jain reports a tenfold performance gain after rebuilding the system. To explain the design, he first separates short-term and long-term memory. Short-term memory is the working memory of the active session, the material the agent has in hand as it works. Long-term memory has two parts. Fact-based memory holds information the agent can draw on later. Experiential memory holds lessons abstracted from what happened when the agent and its users actually did the work.

The team gave those lessons three forms. The **case base** preserves a detailed situation together with the detailed learning from it. This is useful when a later reader needs the circumstances to understand why a decision made sense. The **strategy base** captures a conditional judgment. Given a situation of this kind, what approach worked for the team, and what should the agent try when it encounters those conditions again?

The **skill base** holds something the team can generalize well enough for the agent to use repeatedly. The distinction is the reach of the lesson. A correction can be worth keeping in full even if the team has only seen that particular case. A strategy identifies the conditions under which an approach has proved useful. A skill carries the reusable part of the work forward once the team can separate it from the particulars of the original experience.

![Three illustrated panels pair cases with a stack of cards, strategies with a route on a folded map, and skills with a multitool. Each panel asks a question.](https://ai.engineer/api/talk-essay-media/d51757edd2d69a54b9dd409254ef9155d61872ee4ca6860c59aa97fc28c2b3cd)

The Missing Layer: Experiential Memory

### A revised judgment needs a history

[4:05](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=245s)

Once the team could preserve experience, it faced a problem that a fresh memory store conceals. The data changes, the systems the agent works with change, and the surrounding environment changes. An approach that works today may be a poor choice a month or a year later. After a series of experiments, Jain’s team organized the memory lifecycle around three operations he calls **formation, updation, and retrieval**.

Formation captures a fact or an experience in a memory record. Updation keeps the collection current as further evidence comes in. The system can add a node for something newly encountered, revise an older node, or deactivate one that has ceased to be useful as guidance. Retrieval determines which of those records will inform the task in front of the agent. One decision about updating turned out to matter particularly for retrieval. What should an investigator see after the team has changed its mind?

![Double-headed arrows connect three illustrations. Media icons feed into a stack under “Formation,” arrows circle layers under “Updation,” and a robot points to an image under “Retrieval.”](https://ai.engineer/api/talk-essay-media/57668146ffd0d9947cdd12ec5b95dd4b20cb68c7605e61e3d5c42c51d4dca9ec)

Formation, Updation, and Retrieval

Keeping only the final judgment creates a way to repeat an old error. An agent investigating the issue later can reason its way back to the earlier conclusion, unaware that the team already reached and revised it. Jain therefore distinguishes two depths of lookup. Surface-level research uses active nodes. Deeper research can consult active and inactive nodes together. Inactive nodes preserve the sequence of earlier judgments, so an investigator can trace the route to the current one without putting superseded advice into every routine session.

### Why the memory lifecycle includes forgetting

[6:13](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=373s)

Jain illustrates the cost of indiscriminate recall with the case of Solomon Shereshevsky, a man known for his extraordinary memory. In Jain’s telling, a choice most people could make in a second might bring a hundred recollections to mind, each seeming as relevant as the next. Shereshevsky could recall the details. The difficulty was deciding which one mattered for the choice in front of him.

An agent can accumulate the same burden. Every obsolete fact or incidental observation it brings forward is another item to weigh on the next task. Deactivation serves a particular purpose when an earlier conclusion explains a later decision. Forgetting serves a different purpose when material has ceased to be true or relevant and recalling it contributes little. The system needs a way to make both decisions, or the cost of working through accumulated context returns.

### A model capable of checking proposed changes

[7:42](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=462s)

At this stage the team had agents that could use experience and a memory system whose contents could evolve. Maintaining it still took manual work. Jain asks what had changed in the preceding six months to make the next step possible. His answer concerns a particular use of stronger models. A model could now serve as a **verifier**, taking on review work that had previously required a human to inspect each item.

That gave the team a way to build review into the system itself. Extracting a plausible lesson from a session and deciding whether it belongs in live memory could become separate operations. The verifier would have a place in the recurring evaluation process Jain describes later.

### A correct address sends the agent to the wrong coast

[8:43](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=523s)

For Jain, retrieval sets a ceiling on the performance of the whole system. He asks the audience to suppose he has homes in San Francisco and New York. Leaving his San Francisco office, he asks his agent to pull up directions home. Midway through the hypothetical journey, he realizes the route is taking him somewhere unexpected. The agent has picked his New York home.

Both stored addresses are correct. The word “home” fits either one. The decisive information is where he is leaving from and which home he means on this occasion. An agent can generate directions competently from the record it receives and still fail the request. The same dependency applies to a carefully maintained strategy. Forming the right lesson and keeping it current only help when retrieval supplies it in the circumstances where it applies.

Jain gives a measured comparison for work the team repeated. Gathering context for the agent had taken about 20 minutes in many cases. When the same agent had gathered that context before and knew what to gather again, the step took about two minutes. That is the scope of the tenfold timing improvement. Jain also reports lower token cost and less effort, with better performance on long-horizon tasks because the agent could reuse decisions the team had already thought through.

### What happens during a dreaming cycle

[10:28](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=628s)

Jain calls the recurring maintenance passes **dreaming cycles**. His analogy is a night’s sleep. Between periods of active work, less important material can be cleared away, items deserving attention can move forward, and the remainder can be reorganized. An agent that keeps acquiring context needs time designated for those operations or its priorities will increasingly reflect what happened to accumulate.

![Clockwise arrows connect Observe at the top, Reflect at the lower right and Evolve at the lower left, then return to Observe.](https://ai.engineer/api/talk-essay-media/79699fc90bd779a4d5cf8189460f80752871decae68a95f90659a43932138a7e)

Dreaming Cycles: How Agents Learn While You Sleep

He draws three operating rules from the work. First, disclose memory progressively, starting with what the present task calls for and making more available when deeper inquiry warrants it. Second, keep improving the system as its environment changes. Third, put the maintenance procedure into a loop. A prompt can guide an individual session. A loop specifies when the system will revisit what it learned and how a proposed change reaches the next session.

The build order matters. The team first implemented formation, updation, and retrieval, then added observability around those operations. On top of that it built the loop and evaluation layer. After a session or at the end of a day, the process extracts lessons, proposes improvements, tests them independently, and then applies the changes in the live system. Jain leaves the detailed evaluation design and the security guardrails for a separate discussion.

### The next teammate is where learning pays off

[12:54](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=774s)

Return to the ten engineers. In one calendar year, each person directly experiences one year of work. A shared agent can participate in work with all ten. What changes the handoff is that a judgment acquired with one engineer can now be available when the agent encounters a similar problem with another. Over time, its range of experience can extend across domains that no individual teammate regularly works in.

Jain says he has already seen teams of people and agents working together this way. He describes some as “10X or 100X” teams. The figure he puts a clock to is the time spent gathering familiar context, which fell from twenty minutes to two. His forecast for the next six to nine months goes further: he expects more autonomous AI companies in which agents collaborate and carry what they learn from one interaction into the next. For the hedge fund executive, the immediate test is simpler. When a different teammate starts a fresh session, can the agent put the earlier correction to work?

## Key takeaways

- Preserve a correction at the level the evidence supports. Keep the detailed case, record a strategy with its conditions, or extract a skill the agent can reuse.
- Use active records for routine retrieval and make superseded judgments available for deeper investigation. Give obsolete material a path to be forgotten.
- Evaluate retrieval in the circumstances of the request. Two accurate records can imply very different actions, as the San Francisco and New York addresses illustrate.
- Observe the memory lifecycle before automating edits. Extract lessons between sessions, test proposed changes independently, and check whether the next teammate benefits.

## Slides

### Two Years of Experience. Zero Learning

[1:06](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=66s) [A presenter inset overlaps the end of the blue phrase “Zero Learning.” Three bullets contrast engineers gaining experience with agents repeating mistakes.](https://assets.ai.engineer/sites/aiecode2025/sha256/feccdab659406e5c72f8015ab9dc235104d37d68cedd9dfa4bd33709761fff8c.webp)

Two Years of Experience. Zero Learning

• Engineers gain experience.
• Agents repeat mistakes.
• Where does the learning go?

### More Context ≠ Better Intelligence

[1:38](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=98s) [A blue inequality sign separates “More Context” from “Better Intelligence” in a two-line heading. Three bullets below name tokens, latency, and performance.](https://assets.ai.engineer/sites/aiecode2025/sha256/2664fc3755ae9cf0cbddd54c63b6c3625117e280d039c826db6ae1073fb8654f.webp)

More Context ≠
Better Intelligence

• More tokens.    • More latency.    • Diminishing performance.

### Memory Isn’t Learning

[2:26](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=146s) [The heading on the left highlights “Learning” in blue. Three rows on the right describe what facts tell us, what experience tells us, and how judgment changes.](https://assets.ai.engineer/sites/aiecode2025/sha256/1a31e1d5dbd40344e32f8cd8cbefe1f4a821ad5b5c3be71b34a988132c5ff1f5.webp)

Memory Isn’t
Learning

• Facts tell us what.
• Experience tells us how.
• Judgment improves with time.

### The Missing Layer: Experiential Memory

[3:26](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=206s) [Three illustrated panels pair cases with a stack of cards, strategies with a route on a folded map, and skills with a multitool. Each panel asks a question.](https://assets.ai.engineer/sites/aiecode2025/sha256/d51757edd2d69a54b9dd409254ef9155d61872ee4ca6860c59aa97fc28c2b3cd.webp)

The Missing Layer: Experiential Memory

Cases:
What happened?

Strategies:
What worked?

Skills:
What can be reused?

### Less Context. Better Decisions.

[5:09](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=309s) [On a dark background, “Better Decisions.” appears in blue. Three bullets advise limiting what gets loaded, retrieving relevant material, and disclosing it progressively.](https://assets.ai.engineer/sites/aiecode2025/sha256/83a71a4cefd539756c36323a82d5a9b0d725be1dae13ea805891930345f33a2a.webp)

Less Context. Better Decisions.

• Don’t load everything.
• Retrieve what matters.
• Disclose progressively.

### Formation, Updation, and Retrieval

[5:13](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=313s) [Double-headed arrows connect three illustrations. Media icons feed into a stack under “Formation,” arrows circle layers under “Updation,” and a robot points to an image under “Retrieval.”](https://assets.ai.engineer/sites/aiecode2025/sha256/57668146ffd0d9947cdd12ec5b95dd4b20cb68c7605e61e3d5c42c51d4dca9ec.webp)

Formation    ↔    Updation    ↔    Retrieval

### Dreaming Cycles: How Agents Learn While You Sleep

[10:47](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=647s) [Clockwise arrows connect Observe at the top, Reflect at the lower right and Evolve at the lower left, then return to Observe.](https://assets.ai.engineer/sites/aiecode2025/sha256/79699fc90bd779a4d5cf8189460f80752871decae68a95f90659a43932138a7e.webp)

Dreaming Cycles: How Agents Learn While You Sleep

Observe
Reflect
Evolve

### Three Golden Rules

[11:36](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=696s) [Three outlined cards present the rules from left to right. A speaker inset overlaps the top of the third card, leaving all three rules readable.](https://assets.ai.engineer/sites/aiecode2025/sha256/90f602c3cfc75f30009d8a38625353d767aa2f37202fc963ded4299ce785ffdc.webp)

Three Golden Rules

Disclose
progressively.

Improve
continuously.

Engineer loops,
not prompts.

## Full transcript

[0:00](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=0s) You've worked with your AI agent for the last two years. You gained two years of experience. Your agent, none. Ten people on your team worked with the same AI agent. They cumulatively gained two decades of engineering experience. Your agent, still none. It keeps on repeating the same mistakes again and again.

[0:27](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=27s) I was talking to a senior executive at the world's biggest hedge fund, and he said, "Sparsh, the problem is not that the AI of the agents are not smart. The problem is that it keeps on repeating the same mistakes again and again. If I course correct it today, then in the next session or with another team, it just makes that same mistake again. And the issue is that there are so many mistakes that we cannot

[0:56](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=56s) improve those things at all times. We need a mechanism or we need a system to resolve this issue." And at that point of time, we realized that everyone is talking about context. Everyone is talking about memory. And the answer is, we just need to take all the context, all the memory, and give it to agent such that it will figure out. It was good in the start, but soon we realized at enterprise scale, the issue is the

[1:26](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=86s) context can be too big, and giving all the facts to the agent does not increase the performance. It increases the cost, it increases the effort, it increases the overall time taken. And on top of that, it decreases. It decreases the overall accuracy, that is, it decreases the performance. And there we realize that more context doesn't equal to better intelligence after a point. When you are-- when we are starting, when we have a smaller context space, yes, it means that, but after a point of time, it doesn't mean that. And we need a better mechanism, a better way to solve that

[1:56](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=116s) problem. Here, we went to the-- back to the drawing board. Think like, how... Why exactly we humans we get better with time? And at that point of time, we realize we humans have this skill of experience, of a judgment. And this judgment layers gets better with time when we learn something, when we make mistakes, and when we course correct it. And that is a missing piece from a lot of

[2:25](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=145s) these agents.

[2:29](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=149s) And there we realized that at this point of time earlier, the memory was not learning for us.

[2:39](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=159s) When we came back, when we built the system, the performance gain for us was 10X. And what exactly we came upon as the understanding of the memory is, it's divided into two parts: the short-term memory and long-term memory. Short-term memory is the working memory or active session memory. The long-term memory is divided into two parts: fact-based memory and experiential memory. This

[3:09](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=189s) layer of experiential-based memory was something that has been missing now, and these are the abstracted out learnings from whatever we do with agents. And this is what makes we humans different from the AI that was there earlier. And further, this experiential layer can be doubled down into three different categories: the case base, strategy base, and the skill base. Case base is the detailed case and the detailed learning. The

[3:38](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=218s) strategy is if you were in that particular situation, then what kind of strategy work for us and what we should use. And then finally, is something that can be abstracted out, generalized very well. We abstract that thing out into a skill which an agent can use again and again. And this is how we build this experiential layer in the agents. This experiential memory is something that helped us.

[4:05](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=245s) At this point, we thought we have solved the problem of memory infrastructure. But solving this problem made us realize that this is just the start of the problem, and there are so many other bigger problems out there that form just because we solved this problem, and we are able to see it because we reached this stage. And that is in the current times, the systems are changing very fast. The data drift, the system drifts, the overall-- the whole

[4:35](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=275s) environment drifts. The world is changing every week, every month, and year feels like a decade in the AI age. So the agent that works today doesn't work in a month or a year's timeframe, and we need to think through how we update that thing. And once we ran through a lots and lots of experiments, we came upon this understanding of the memory is that it's not just you make the system or the memory once, but it's just you have to evolve or make it better with time.

[5:06](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=306s) And then in the final case, we came upon this architecture, that

[5:13](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=313s) memory infrastructure pipeline is divided-- the lifecycle is divided into three parts: the formation, the updation, and the retrieval. Retrieval is very important. Now, formation we already understood right now. The updation is the part which evolves the system, in which you add new nodes when there are new experiences or facts. You update the older nodes or like deactivate the nodes

[5:43](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=343s) which are no longer useful. And then finally, you have this forgetting. In updation, only storing the final layer of judgment is not enough in all case. Because if you just store that, the agent can make a mistake and go back to the older point which had-- which was earlier and we just removed it. So a better way is if it's a surface level research, it just looks at the active nodes. And if it's a deeper research, it looks at the active nodes and the inactive nodes. And inactive nodes are the temporal journey that the system took

[6:13](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=373s) to get the final layer of the judgment that is there. And then finally is the forgetting node, which is a must have been very important here, and we cannot forget it. Let me give you an example. In the late twentieth century, there was a person named Chevy Sherowski. This is a human with near perfect memory with a hundred percent recall. Now you might be thinking, if we have got that particular memory, our

[6:43](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=403s) life would have been amazing. But when the scientists and researchers studied his life, they started to realize a lot of times when he even has to make a smaller decisions, his life was miserable because every point used to compete for an equal prioritization and equal winning in things. For something which we humans can take in a decision in a quick second, it was a hundred thoughts fighting in his mind, and he gets

[7:13](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=433s) overwhelmed. And that is the issue with our agents. If you keep on adding everything, if you keep on accumulating everything, and if you do not forget things which are no longer true or which are no longer required, then you might end up in a state where

[7:30](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=450s) the system gets overwhelmed, and it-- the results just doesn't get better with time. So you need to have a mechanism to forget things.

[7:42](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=462s) Now, once we build this pipeline, we started with providing this memory to agents. We built this experiential agents. Now we built this evolving experiential agents, but still everything is manual. We thought we have solved the problem, but what's possible today, it was just half of the solution. Let me ask you a question. In the past six months, what has changed in the AI world?

[8:13](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=493s) The models have become smarter.

[8:17](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=497s) But that's only a smaller part. The bigger breakthrough is that the model is so smart enough that it can be the verifier. Until now, the situation was we always have to have the humans in the loop to review everything. But now for the first time, the model is smart enough such that we can bake that thing into a layer in itself as a verifier into the system so that the system gets better with time by itself.

[8:43](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=523s) And then finally, we had this retrieval part.

[8:48](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=528s) Now, in the retrieval aspect of things, your system's maximum performance can be just equivalent to the maximum performance of the retrieval.

[8:59](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=539s) You might be asking why. Let me give you an example. Let's say I work in San Francisco, and I have a home here. I also have a home in New York. I got off out of my office, and I asked my AI agent, "Pull the maps for the home." Midway through the route, I realize this is not a place where I should be going. And then I realize I wanted to go to my San Francisco home. For the agent, the home is home, whether

[9:29](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=569s) it's New York or San Francisco, and it put the map for the New York home. And there I realize

[9:36](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=576s) no matter how good my system is, the formation and the updation and the knowledge I have and the experiences I have, if my retriever doesn't give me the right information, it's just of no use. The whole system is of no use. And that's where the retrieval part of our system is very, very important.

[9:58](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=598s) And then finally, once we have this thing, we have the formation, the updation, and the retrieval. This is how we complete the life cycle of the memory infrastructure we have. And let me tell you, earlier for gathering context for our agent, for a lot of cases, it used to take twenty minutes. But now if we have gathered that context earlier and we know what all to gather, that same agent just takes two minutes of time. And that's not only the improvement in the timing, it, it is improving in the efforts it has to make... it can make. It, it improves in the tokens it costs, and it overall

[10:28](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=628s) improves the performance of our agents in the long horizon task because it doesn't have to think through too much in the things we have already thought earlier. And this is just the start of the system. Now the next level comes. That is how we made the system self-evolving and experiential. And in that particularly, we built this concept of cycles or dreaming cycles. Now, we humans have a tendency when we take rest

[10:58](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=658s) or when we sleep, our mind, it cleans the things which are no longer important. It takes the prioritized items to the front, and whatever is left, it rearranges and cleans everything, such that next day when I wake up, I feel very refreshed. I can think clearly. And that is something we build within the agents. We build this looping and the eval infrastructure such that we clean the things which are no longer important, we update the things which should be prioritized, and

[11:28](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=688s) we rearrange the things such that the next day and whenever the context is getting accumulated, the agent is able to perform better and better.

[11:38](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=698s) And then finally, once you build this infrastructure, earlier the issue for us was the agents cannot remember anything. But now with the two years of experience, we are able to give more experience to the agents than any one of us humans. And we learn that there are three golden rules when we are building this experiential memory. First Do not dump everything. You have to remember, you have to disclose progressively. Second,

[12:08](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=728s) you cannot make a system once and assume it will always perform good. You have to improve the system continuously. And then finally, instead of writing prompts, you have to move towards writing these loops because that is how you make this whole infrastructure for you autonomous. An example for us is once you build this, uh, memory layer formation, updation, and retrieval, we built an observability layer around it. Once we have observability, we built this looping layer

[12:38](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=758s) combined with the eval layer such that which after every session, after every day, extracts the learnings, improves the systems, test it independently, and then finally make the changes in the real system.

[12:54](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=774s) Now, this looping, these evals, and the security guardrails around the whole memory infrastructure is a very interesting topic, but that's a topic for my next talk. And coming back to the problem we had that we were not getting experiences. Now, with this thing, we-- whenever the agent work with me, it gains that experience. Whenever it, it works with anyone of, on my team, it gains that experience too. So for me as a human, I'm ga-gaining, getting only one

[13:24](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=804s) year of experience in one year. But this agent, since it's working with all those 10 members, it's getting that 10X experience, and it's getting better than any one of us in the team. And now because of that, we have started to see these autonomous teams of humans plus AI agents combined. And in some of the teams, I know, like their team is like 10X or 100X because this agent that they have created, this agentic infrastructure and the memory behind it, it just-- that is powering them. It's just empowering these agents such that some of these agents are far better than any of the

[13:54](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=834s) best engineers or people or employees out there in their team. And soon, like in the next six to nine months, we has-- we will start to see more and more of these autonomous AI companies in which agents are collaborating with each other, and they just remember everything. Such that now if you implement these things, whatever performance you have, it just will compound exponentially with time because it's not learning only with you. It learns with every member of the team, and it gets better and better with

[14:24](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=864s) time. Such that in the near future, there will be a stage within your enterprise where this agent has learned more than any one of our person in the different domains, in the different judgment.

[14:38](https://www.youtube.com/watch?v=SUqQlvyI3N8&t=878s) And I would like to tell this one thing is people who do not remember from the mistakes, or the agents who do not remember from their mistakes, are condemned to repeat it. Build this memory infrastructure and get back to growing exponentially better and build a 10X or 100X team.
