Learning Machines: the memory that cracked ARC-AGI-3 public set

In January we proposed that memory is the wrong abstraction and what agents really need is the ability to learn. Learn about users, their environment, their purpose, their goals. Learning is what lets an agent do something better next time.

We then released Learning Machines. At the time we had no evidence that learning would beat a traditional memory system but we knew it was the right direction.

Over the last few weeks we let agents play ARC-AGI-3, with no instructions, no rules, and let them learn from each run. Then we took one model's learnings and handed them to completely different models to see whether any of it was any use to them.

The short version is that gpt-5.6 scored 100.00 on the ARC-AGI-3 public set. Then a smaller model (gemini-3.7-flash), learning from gpt-5.6's notes, scored 96.42, beating the human baseline of 95.4. Read more about it here.

This means that a) learning compounds: an agent that learns gets better the next time it attempts the same task. And b) learning transfers: you can solve something once with your best model, then share the learnings with smaller, cheaper models.

What is ARC-AGI-3?

ARC-AGI-3 is a set of small video games. An agent is dropped into a game with no instructions, no rules and no goal. It sees a grid of colored cells and it has seven buttons. It doesn't know what any of the buttons do, what kills it, or what winning looks like. It has to work all of that out by taking actions and doing things.

Agents are scored on efficiency, not just on winning, so an agent that stumbles into a win after a thousand flailing actions scores far worse than one that works out the mechanics and then plays cleanly. ARC describes what they're measuring as skill-acquisition efficiency over time, and, the ability to update beliefs as new evidence appears. In plain english, ARC-AGI-3 is a test of learning.

Cross-model learning transfer

GPT-5.6 scoring 100 is not of interest to me. What I want to know is how well this learning transfers to other models. So that we can go from model-routing to agent-routing. Routing to an agent that works 96% of the time for a certain set of users, while the frontier model distills learnings on the fly is the holy grail of agentic systems.

We want continual learning at the system-level, not just the model-level.

To test this out we took GPT-5.6's learnings and gave them to Gemini-3.7-Flash that scored 37.33 cold. Reading GPT-5.6's notes it scored 96.42, beating the human baseline of 95.4. We did the same with other models and resutls were similar.

So what is a learning machine?

A learning machine is a collection of learning stores, each capturing a domain of knowledge while the agent runs. Here are the built-in stores that come with Agno:

A learning store defines: what type of information to capture, when and how to capture it, and how to use that information to steer the agent's behavior.

Learning machines are extensible. The ARC player brings its own GameLearningStore. It's 137 lines, backed by a markdown file, and plugs into an agent as one argument:

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.learn import LearningMachine
from agno.tools.code import CodeMode
 
player = Agent(
    model="openai:gpt-5.6",
    db=SqliteDb(db_file="agent.db"),
    # the game, plus a stateful python kernel for free analysis
    tools=[game, CodeMode(allow_shell=False, timeout=120)],
    # the agent learns the rules of the game as it plays
    learning=LearningMachine(custom_stores={"game": store}),
    # long kernel outputs stored as pointers
    offload_tool_results=True,
    instructions=INSTRUCTIONS,
)

This means a legal agent can have its own learning store to capture the rules of the law, while a sales agent can have its own learning store to capture the details of the sales process. Learning stores are simple to build. They look like this:

class LearningStore(Protocol):
    def recall(self, **kwargs) -> Optional[Any]:
        # what do you know? read it back from wherever you keep it
        ...
 
    def build_context(self, data: Any) -> str:
        # how should that show up in the agent's system prompt?
        ...
 
    def get_tools(self, **kwargs) -> List[Callable]:
        # what tools does the agent get for writing back to you?
        ...
 
    def process(self, messages: List[Any], **kwargs) -> None:
        # optional: pull learnings out of the conversation after a run
        ...

Built-in learning stores

Most agents aren't playing a video game. Agno comes with learning stores for day-to-day operations: user profiles, session context, entity memory, decision logs.

Each store has a mode. ALWAYS runs the learning process automatically after a response. AGENTIC gives the agent tools and lets it decide.

I use AGENTIC most of the time. Automatic learning is still a bit meh... You see when you run the learning process every time, agents tend to find something, always.

User Profile

The User Profile store captures structured fields about a person. Name, role, preferences, plus whatever you add with your own schema. The agent gets an update_profile tool and calls it when it hears something worth learning.

agent = Agent(
    model=OpenAIResponses(id="gpt-5.6"),
    db=db,
    learning=LearningMachine(
        user_profile=UserProfileConfig(mode=LearningMode.AGENTIC),
    ),
)
 
agent.print_response(
    "Hi! I'm Robert Johnson, but everyone calls me Bob.",
    user_id="bob@example.com",
)

Unlike user memory which is unstructured (see below), user profile is structured and defines what the agent should learn. Eg: if you're building a teaching agent its good to know the student's current level, their learning style, and their goals.

User Memory

User Memory is the unstructured half of the user profile. The things that don't fit a field but change how you'd answer.

learning=LearningMachine(
    user_memory=UserMemoryConfig(mode=LearningMode.AGENTIC),
)
 
agent.print_response(
    "I'm a backend engineer at Stripe. "
    "I specialize in distributed systems and prefer Rust over Go.",
    user_id="bob@example.com",
)

The tool here is update_user_memory. The extraction prompt is deliberately anti-accumulation: it tells the model to prefer updating an existing memory over adding a new one.er.

Session Context

Session Context tracks the work rather than the person. What's been discussed, what was decided, where we are. It's replaced after every run rather than appended, and each pass is handed the previous context, so a long task keeps its thread even when the message history gets truncated out from under it. It's ALWAYS-only.

learning=LearningMachine(session_context=True)

Entity Memory

Entity Memory learns everything that isn't the user. Customers, teammates, projects, systems. Context graphs, company brains, personal CRMs; all benefit from this.

learning=LearningMachine(
    entity_memory=EntityMemoryConfig(namespace="sales"),
)
 
agent.print_response(
    "Note on Acme Corp: fintech startup in SF, about 50 people. "
    "Jane Smith is their CTO.",
)

Entity Memory is agentic by nature, with four tools: remember_about, link_entities, search_entities and forget.

Decision Logs

Decision Logs records what the agent chose and why, including the alternatives it passed on. The tools are log_decision, record_outcome and search_decisions. With a decision log you can ask the agent why it did something three weeks ago.

learning=LearningMachine(
    decision_log=DecisionLogConfig(mode=LearningMode.AGENTIC),
)

Learned Knowledge

Everything above is about a person or a session. Learned Knowledge is about learning insights, patterns, gotchas. Learned knowledge is shared knowledge across users, across teams. This is one of the most powerful learning stores.

agent = Agent(
    model=OpenAIResponses(id="gpt-5.6"),
    db=db,
    learning=LearningMachine(
        knowledge=knowledge,
        learned_knowledge=LearnedKnowledgeConfig(mode=LearningMode.AGENTIC),
    ),
)

One engineer tells it something:

agent.print_response(
    "We're trying to reduce our cloud egress costs. Remember this.",
    user_id="engineer_1@example.com",
)

A different engineer, in a different session, asks a related question:

agent.print_response(
    "I'm picking a cloud provider for a data pipeline. Give me 2 key considerations.",
    user_id="engineer_2@example.com",
)

and gets an answer shaped by what the first one said. The agent gets search_learnings and save_learning tools. Learned knowledge is the conceptually the closes to our GameLearningStore.

Build your own learning store

The magic behind Learning Machines is the Learning Store protocol. You can implement it for anything you'd like your agent to learn.

Say you want project context to follow an agent around:

@dataclass
class ProjectContextStore(LearningStore):
    context: Dict[str, Any] = field(default_factory=dict)
 
    def recall(self, **kwargs) -> Optional[Dict[str, Any]]:
        return _project_data.get(self.context["project_id"])
 
    def build_context(self, data: Any) -> str:
        lines = [f"{k}: {v}" for k, v in (data or {}).items()]
        return "<project_context>\n" + "\n".join(lines) + "\n</project_context>"
 
    def process(self, messages: List[Any], **kwargs) -> None:
        # pull whatever matters out of the conversation and save it
        ...

Then plug it in exactly the way the game store goes in:

agent = Agent(
    model=OpenAIResponses(id="gpt-5.6"),
    db=db,  # the agent needs a db for learning to initialize
    learning=LearningMachine(custom_stores={"project": project_store}),
)

Legal documents, patient history, a sales pipeline, an incident timeline, the mechanics of a video game nobody has written down. You can build a store for anything you'd like your agent to learn.

Learn more

Agents are going to be the primary consumer of most software. Users will use your product through their agent, your in-product agent, or have their agent talk to your agent. By the end of the decade, having the best product will be synonymous with having the best agent.

Every builder knows that building the "best" of anything is not a one-time effort. It's a continuous grind of learning and improving, learning and improving. Learning Machines is the foundation of that continuous improvement.

To learn more, checkout the learning cookbook, the ARC-AGI-ARCADE or the docs.

Reach out if you run into any issues.