Agents That Learn

Introduction

We were promised AI that learns. What we have is AI that guesses. Now reliability is becoming what stands in the way between a demo that gets us excited and category defining software.

Step off the beaten path as a test, ask today's state-of-the-art agent to do something truly novel, and you'll see it: a misstep, a hallucination, a vague search through irrelevant web pages or code lines. You guide it in the right direction, and after some frustrating back and forth, you might reach a solution in the end. But ask again, and it's no better. It hasn't remembered anything, it hasn't learned anything.

Was it worth the time? Some think not.

That's not intelligence, just a myopic subset. Most importantly, it is not reliable.

The truth is, most AI agents today are stuck in time. Stuck in the knowledge cutoff of their base models and the quality of their tools or basic memory system. Stuck in a world where learning is a luxury: offline, gated behind benchmarks or large dataset requirements, or designed for another user's success.

But the world isn't static. Neither are the tasks we want done.

So we started asking:

What would it take for agents to learn "like people"?

Not from large training datasets, but from day-to-day experience. From each other. From us (users). Continuously.

Introducing The Memory Company: A Protocol for Collective Learning

The Memory Company is our attempt to address this fundamental limitation. Not another model, not another framework: a protocol for shared memory and continual learning across agents, across companies, across models and across frameworks.

The thesis is simple:

• Agents need to adapt continuously.
• Adaptation requires real-time exploration, discovery, and learning.
• Real-time learning requires memory (assimilation, evolution and retrieval)
• Memory, when shared, becomes a learning multiplier.

We're not talking about user preferences or personalization here. We're talking about shared, experiential knowledge that can improve the performance, efficiency, and capability of agents that share a practice or domain.

What if every successful completion, every prompt, fix, and workaround discovered with a user, wasn't a throwaway but a shared stepping stone? What if your agent didn't just remember your history, but could benefit from everyone else's too?

This is the obvious, yet remarkably profound realization behind The Memory Company.

Learning, Reframed

People generally think of learning as something internal. A parametric weight update. A loss function. But there are different layers to it. We think it starts with memory.

Learning is what happens when an agent completes a task, reflects on what worked or didn't, and commits its experience to memory. Not a log. Not a replay. A deeper, more profound lesson.

This kind of feedback, when represented and shared safely, can become a valuable learning episode for others. One agent's experience becomes another's shortcut. Mistakes don't get repeated, they get abstracted, consolidated, and converted to pieces of reusable knowledge.

The system improves itself, as do the agents using it. Not in an abstract sense. In the unpredictable real-world conditions, in real-time.

Memory, Networked

Think of The Memory Company as the hippocampus for a community of AI agents.

A mechanism for transforming, assimilating and resurfacing raw experience into something retrievable, composable, and useful, not just for one agent, but for many.

Drawing inspiration from the modular and adaptive nature of human memory, The Memory Company structures its memory as a collection of specialized subnets. Each subnet acts as a dedicated memory region, encoding and optimizing feedback and knowledge within a particular domain, much like expert regions of the brain that specialize in certain types of information or skills.

Certain communities may be directly overseen by practice owners. For example, developer ecosystems often have maintainers or corporations invested in improving their community productivity over time. Other communities may operate under open-ended governance structures (e.g. Linux Foundation). Some might be fully open, others private.

Each subnet inherits the same core protocol; agents can contribute, retrieve, and learn, but what they learn, and how they learn, is shaped by the contours of the specific problem space they service.

By connecting these subnets, The Memory Company enables agents to benefit from both local expertise and global knowledge, fostering collaboration and continual improvement. This architecture marks a shift from static, user-centric memory to a dynamic, community-driven memory network, one that can scale, adapt, and evolve around a domain and alongside its users.

To illustrate the protocol's properties we've started with two domains where we think the barrier to true scalability & reliable performance today lies in the lack of continuous learning:

• Developer Productivity (with Code Agents), the most prevalent category of GenAI in 2025
• Software autonomy (using Code Agents), the most promising category of Agentic systems as of 2025.

We call the first Spark. The second, Omni.

Spark: Collective Memory for Code Agents

You've seen this problem if you've used Cursor, or GitHub Copilot, or other code agents.

They're helpful. But when they get stuck? You're alone.

This is because the error you just debugged, the workaround you just found, no one else benefits from it. Not even your next agent session. And that also means that if you stumble on something your agent can't fix, you are on your own.

That's what Spark is designed to fix.

Spark is a subnet of The Memory Company focused on agentic developer workflows. It turns agent output and interaction traces into memory objects which are retrievable, generalizable, and reusable. It augments traditional documentation with real, contextual usage. And it closes the learning loop that was broken by AI in online communities (see Stack Overflow is almost dead).

An agent that solves a coding task using Spark contributes to the success of the next agent. It doesn't just consume knowledge. It gives back.

For Developers, it feels like a just-in-time community recommendation, it feels like coding with the entire community behind you. It understands your intent, pulls from the most relevant code patterns, examples, and live references, surfacing the best paths forward, precisely when and where you need them.

For Ecosystems, it's a control plane for developer experience in the age of AI. You can track how agents use or struggle with your docs. Identify friction, measure freshness of your examples, and uncover opportunities for improvements, all while keeping your documentation aligned with evolving usage.

And for Agents, it's the first taste of collective learning.

This is just one example of a community of practice organized around a shared memory, but many more will emerge, each rooted in different domains and driven by their own agentic workflows.

Omni: A Learning Layer for Adaptive Agents

If Spark is a memory region for code agent shared practices, Omni is a memory region for shared discoveries for adaptive agents.

Unlike traditional agents that rely on predefined tools and structured outputs, adaptive agents are built to operate in unpredictable environments using code. They don't follow predefined sequences or graphs for the most part, but figure out in real time the most optimal action trajectory. Their specialty is discovery.

They power workflows where the "how" isn't or cannot be known upfront; the optimal action path needs to emerge through trial, observation, and reflection.

Think of a research agent, like OAI Deep Research, sifting through a chaotic mix of formats, PDFs, UIs, APIs, spreadsheets, video transcripts, extracting insight, learning how to handle each new variation. Or a security agent, acting as a first line of defense, needing to adapt to threats it hasn't seen before.

Note: If you want to have a play with it, have a look at Agent Zero, an agent framework that autonomously builds, adapts, and uses its own tools in a secure virtual environment or smolagents that lets you create AI agents that "think in code", meaning, they solve tasks by generating and running Python code.

Every interaction is an opportunity to revise the plan: run code, observe output or errors, self-correct, repeat. This is the loop adaptive agents use to continuously improve with minimal human intervention; it is the most promising general form of autonomy and is a perfect candidate for large-scale continuous learning.

With The Memory Company Omni, these agents get better over time, because their past attempts are shared, contextualized, and synthesized by the network beyond what a single agent alone can do. In defining their next steps, an Omni-enabled agent can directly run action trajectories previously ran, converging to optimal solutions much faster.

You're no longer running a single agent through a novel task. You're a participant and consumer of a distributed learning protocol, with agents all building on each other.

Every time an agent fails, the memory learns. Every time it succeeds, the solution path gets clearer and more efficient (akin to backpropagation). And every new user that joins the network will benefit from every past user's attempt, creating a powerful network effect.

Omni offers a first glimpse into collective discovery. As more agents tackle the unknown, we'll witness the rise of learning networks tuned to each domain's unique unpredictability.

Conclusion

If we want AI to move beyond novelty and into utility, from demo to dependable value, we need a foundation where reliability compounds. That only happens when learning is not an afterthought, but a design principle of the system. Not locked inside proprietary silos of companies that have enough userbase and data, but built collectively.

The Memory Company is a bet on this future: one where memory is networked, where agents improve through shared experience, and where communities, not just companies, become the engine of progress.

The path forward requires more than smarter models. It demands open protocols, new incentives, and the return of the flywheels that made the web great: collaboration, remixing, collective refinement. If we build systems that learn together, we can make intelligence something that scales with use, and gets better for everyone.