Thicket

Can an AI agents learn? Thicket gives AI agents persistent, evolving world models, allowing them to learn from experience and build an understanding of their environment that grows with every task.

Comment

What If an AI Agent Could Learn Its Environment?

Imagine two software engineers working on the same project. One started this morning, while the other has worked on the project for the last ten years. Both engineers may have access to exactly the same source code, documentation, issue trackers, and other resources. They may even possess roughly equivalent technical skills. Yet, if we ask both engineers to make an architectural decision, we should probably expect very different results.

The difference is not simply that the experienced engineer remembers more facts. Over the course of thousands of interactions with the project, they have developed an understanding of how it works. They know why seemingly strange architectural decisions were made, which parts of the documentation cannot quite be trusted, and which conventions are important even though nobody bothered to write them down. When they encounter something new, they interpret it through everything they have previously learned about the environment in which they work.

Modern AI agents operate very differently. We can give an agent access to a repository, documentation, messages, APIs, and an increasingly impressive collection of tools, but much of its work still begins with reconstructing enough context to understand the problem in front of it. The agent searches, reads, reasons, and gradually develops a useful understanding of its environment. It completes the task, the session ends, and much of that newly developed understanding disappears with it.

Thicket began with a question about what would happen if we changed that last step. Instead of continually giving AI agents better ways to rediscover their environments, what if we gave them a way to learn those environments over time?

Building a World Model

Thicket is a persistent world-model platform for AI agents. It gives an agent a structured representation of the environment in which it operates and allows that representation to evolve as the agent gains new experience. An agent can observe something in its environment, connect that observation to existing knowledge, investigate when something does not make sense, and revise its understanding when new evidence suggests that its existing model is incomplete or wrong.

This is an important distinction from simply giving an agent memory. A memory system can preserve something that happened yesterday. A world model should allow what happened yesterday to influence how the agent understands something that happens tomorrow. Knowing that a team once made a particular architectural decision is useful; understanding how that decision relates to other parts of the system, why it was made, and what assumptions it depends upon is considerably more powerful.

This distinction creates an interesting problem, because I do not know what the ideal world model for an AI agent looks like. There may not even be a single representation that works well everywhere. A software repository, a manufacturing operation, and a research project contain very different kinds of entities, relationships, and concepts. Designing Thicket around a fixed ontology would require deciding what an agent should learn before the agent ever encounters its environment.

Instead, Thicket allows the structure of the world model itself to evolve. Agents do not simply populate a database schema that I designed for them; they can participate in determining what kinds of knowledge should exist and how that knowledge should relate. The representation of the world therefore becomes another part of the system that can develop alongside the agent's understanding of it.

Learning Outside the Chat Loop

Human experience also does not happen only when someone asks us a question. Much of what we learn about the places in which we work happens simply because we are present while things change. We see a new project begin, participate in a decision, notice that a process has changed, or discover that something we previously believed is no longer true.

Thicket applies the same idea to AI agents by allowing them to observe an environment asynchronously. A new commit, changed document, meeting transcript, API event, or other source can become an observation that an agent investigates. Using Gemini, the agent can compare new information against its existing world model, retrieve related knowledge, investigate additional sources when necessary, and determine whether what it understands about the environment needs to change.

The result is a continuous process of observation, investigation, reasoning, and revision. Instead of waiting for a user to provide a prompt and then assembling all of the knowledge required to answer it, an agent can perform some of the work of understanding its environment as that environment changes. By the time someone asks the agent to perform a task, some of the expensive work of understanding the world around that task has already happened.

The Hundredth Task Should Be Different

Consider an agent asked to modify a device-provisioning workflow in a large software project. Without prior experience, it might begin by searching the repository, locating relevant documentation, inspecting related implementations, and reconstructing enough architectural history to understand why the existing system behaves as it does. This is useful work, but it may also be work that another agent performed yesterday.

An agent using Thicket can begin with an existing model of that environment. It might already understand which components participate in provisioning, know about an architectural decision that affects the requested change, and know that a superficially obvious implementation was previously abandoned because it caused a particular failure. The agent should still inspect the underlying source material because a world model can be incomplete, outdated, or simply wrong. The difference is that the agent has somewhere useful to begin.

Whatever the agent learns while completing the task can then influence the model available for the next one. New experiences can introduce new concepts, reinforce existing ones, expose relationships that were previously unknown, or weaken knowledge that no longer appears to accurately describe the environment. Over time, individual interactions stop being entirely isolated events and begin contributing to an accumulated understanding of the world in which the agent operates.

This leads to the simple idea at the center of Thicket: the hundredth task should be different from the first.

Designing for What We Do Not Know Yet

Because so much about agent world models remains an open question, I wanted the architecture of Thicket to preserve the ability to experiment. The system separates the agents performing reasoning from the interfaces through which they access knowledge and from the underlying implementations that represent that knowledge. Different world-model strategies can therefore evolve without requiring every agent or integration to be rebuilt around them.

For this project, Gemini provides the reasoning required to investigate observations and decide how an existing world model should change. Google Cloud provides the infrastructure that allows this process to continue independently of an interactive conversation, while Thicket provides the persistent model connecting one experience to the next. Together, these pieces turn what would otherwise be a sequence of isolated agent interactions into a continuing process of developing an understanding of an environment.

This architecture is intentionally not an attempt to create an enormous prompt containing everything an agent might ever need to know. Humans do not become experienced by replaying every previous experience before making a decision, and endlessly expanding context windows seem like an unsatisfying substitute for understanding. The more interesting challenge is deciding what an agent should take away from an experience, how that knowledge should be represented, and when new evidence should cause its understanding to change.

Where Thicket Goes Next

Building Thicket has increasingly convinced me that there is an important distinction between giving an AI system more information and allowing it to develop experience. Storage is relatively easy. Retrieval is becoming extremely good. The harder problems involve deciding which observations deserve to become durable knowledge, determining how pieces of knowledge relate to one another, handling uncertainty and contradiction, and allowing an agent's representation of its environment to change as its understanding becomes more sophisticated.

Thicket does not claim to have definitive answers to those questions. Instead, it provides a platform in which I can begin asking them with working agents operating in real environments. The adaptable world model is particularly important here because improvements do not necessarily have to come from changing the underlying language model. They can also come from improving the persistent representation through which that model understands the world around it.

Today, we tend to think about an AI agent in terms of its language model, its instructions, its tools, and the context available when it begins a task. Thicket explores whether another component belongs in that picture: an evolving model of the world built from what the agent has learned by operating within it.

Humans do not become experienced because someone eventually writes a sufficiently comprehensive instruction manual for us. We observe the world, act within it, discover when our assumptions are wrong, and gradually build better models of how everything around us works. Thicket asks what happens when an AI agent can begin to do the same.

Built With

Share this project:

Updates