For a long time, when we wanted better results from AI, the answer seemed simple: write a better prompt. Give ChatGPT a clearer instruction. Add more details. Explain the role you want it to play. Tell it what not to do. That approach still works. But as AI becomes more capable, something interesting is happening.

The real challenge is no longer just what prompt should we write? It is becoming:

What information should the AI have, when should it see that information, what should it remember, and how should it learn from what happened before?

This idea is at the heart of context engineering.

In a recent AI DevCon presentation, Anthropic’s Lamis explained how their thinking has evolved from simple instruction files to AI agents that can manage memory and improve through repeated use.

The bigger idea is surprisingly easy to understand: instead of trying to write the perfect prompt every time, we can build systems where AI becomes better because it learns from previous experiences.

From prompts to context

Imagine Avasarant hired a new employee. On their first day, Avasarant gave them a 300-page document containing every rule, process, preference, and piece of advice company has ever created. It sounds useful. But in reality, it would probably be overwhelming. They would spend half their time reading instructions instead of doing their job.

AI agents face a similar problem.

Initially, Anthropic experimented with a simple markdown file containing instructions and preferences for Claude. It worked well because the AI had a central place to look for guidance. But as more information was added, the file became too large.

This is what happens when we keep solving every new problem by adding another instruction. Eventually, the instructions themselves become a problem.

The idea of giving AI a “memory”

Things got interesting from here. Instead of keeping everything in one giant instruction file, AI agents could be given the ability to read, write, and update their own memories.

Think about how humans work. You might learn something on Monday and remember it on Friday. For example, suppose you make the same mistake twice while preparing a monthly report. After the second mistake, you might write yourself a small note:

“Before sending the report, always check the customer numbers against the previous month’s data.”

The next time you prepare the report, you do not need someone to remind you. You remember.

AI agents can work in a similar way. An agent can finish a task, notice what went wrong, and store useful information for the future. This sounds simple, but it creates another problem.

What happens when the AI remembers too much?

Why AI memory can become messy

Imagine asking 1,000 employees to edit the same shared notebook. One person adds a useful note. Another changes it. A third removes something important (Can happen right?). Someone else writes information that is simply wrong.

After a while, the notebook may contain a mixture of useful knowledge, outdated information, personal notes, and mistakes. That is exactly one of the difficult problems with AI memory at scale. Anthropic highlights several issues.

• There is the problem of simultaneous changes. Many AI agents may try to update the same information at the same time.
• There is also the problem of permissions. One agent should not casually change information that affects an entire company.
• And perhaps the biggest issue is memory quality.

A bad memory can be worse than no memory at all. Imagine an AI assistant incorrectly learning that a particular customer always prefers email, when that was only true once. If the system keeps remembering that mistake, it may continue behaving incorrectly in future conversations.

So simply giving AI a memory is not enough. We need a way to manage that memory.

Why Anthropic uses a file-system approach

One of the interesting ideas discussed in the presentation is treating memory more like a file system. Instead of putting everything into one huge block of information, the AI can have many smaller files containing different types of knowledge.

For example:

• customer preferences
• project information
• lessons learned
• previous mistakes
• company instructions
• frequently used processes

The AI does not need to read everything every time. It searches for what is relevant to the task. This is similar to how a person works. If you want to fix your car, you not read every book in the library about engineering. You look for information about the specific problem.

This approach helps AI work with much larger amounts of information without filling its immediate working space with unnecessary details.

What are “skills” in AI?

Another idea discussed by Anthropic is the use of skills. The easiest way to think about a skill is as a small package of knowledge.

Suppose you have an AI assistant that can help with:

• writing emails
• analyzing sales data
• preparing reports
• reviewing code
• creating presentations

Instead of giving the AI all of those instructions every time, it can have a short description of each skill. When a task appears, the AI decides which skill is relevant and loads the detailed information only when needed. This is similar to opening a toolbox. You do not carry every tool around in your hand. You take out the screwdriver when you need the screwdriver.

That simple idea can make AI systems more efficient and easier to manage.

The bigger idea: AI that learns from experience

The most interesting part of the talk: “dreaming.” The word sounds futuristic, but the concept is actually quite practical. Normally, an AI agent is busy doing its current job.

Imagine a customer-support AI answering questions all day. Should it stop after every conversation and deeply analyze what went wrong, update its memory, rewrite its instructions, and study patterns?

It could, but that would make the process slower and more expensive.

Instead, Anthropic describes an out-of-band learning process. After many AI sessions have happened, another process can examine those conversations later.

Think of it like a teacher reviewing a student’s homework at the end of the week. The teacher may notice:

“Several students are making the same mistake.”

That pattern is valuable. The teacher can then update the lesson so future students are less likely to make the same mistake.

The same idea can be applied to AI agents. If hundreds of AI sessions repeatedly fail in the same way, a separate process can detect the pattern and suggest an improvement to the shared memory or instructions.

That is the idea behind “dreaming.” The AI is not just responding. The overall system is learning from what happened.

From a chatbot to a learning system

This changes the way we should think about AI. A traditional chatbot is often viewed as:

Prompt → Answer

A more advanced AI system looks more like:

Task → Action → Result → Memory → Review → Improvement → Better future action

That loop is much more powerful. It is also closer to how humans improve. You try something. You make mistakes. You learn. You remember. Then you perform better the next time.

Why context engineering matters

The future of AI may not be about finding one magical prompt that makes a model perfect. Instead, it may be about designing better systems around the model.

• Where does the information come from?
• What should the AI remember?
• What should it forget?
• Which information should be available immediately?
• Which information should only be loaded when needed?
• Who is allowed to change shared knowledge?
• How do we detect bad memories?
• And how can thousands of AI interactions teach the system something useful without slowing everything down?

These are the questions that make context engineering increasingly important. The model is still the engine. But context, memory, tools, and feedback are becoming the rest of the vehicle. And perhaps the most important lesson from Anthropic’s approach is this:

We may be moving from AI that follows instructions to AI systems that improve through experience.

That does not mean AI magically becomes human or learns everything on its own. It means we can design a system where useful lessons from yesterday become better decisions tomorrow. And that could be one of the biggest shifts in how AI agents are built.

Maybe the next generation of AI will not be defined by better prompts alone. It will be defined by better loops.

You can watch the event here – Lamis Mukta – Learning while you sleep: Beyond memory to dreaming – AI Native DevCon June 2026