Autoresearch is Andrej Karpathy's answer to a question every ML practitioner has asked: what if an AI agent could run your experiments while you sleep? Open-sourced on March 8, 2026, the tool is a 630-line Python framework that lets AI agents autonomously design, execute, and analyze machine learning experiments on a single GPU. No cluster required, no complex orchestration — just an agent iterating through hypotheses the way a researcher would, but without breaks.

The impact was immediate. Shopify CEO Tobi Lütke adapted the tool for his own workflows and reported a 19% validation accuracy improvement on his test problems. The ML community responded with forks, extensions, and integrations within days. For AI research agents and autonomous ML experiments, this is a significant proof point: agents can produce meaningful research outcomes autonomously, not just toy benchmarks.

But Autoresearch shares a limitation common to all current agent frameworks: each experiment run starts without memory of previous runs. The agent that discovered a promising hyperparameter combination at 3 AM has no way to carry that insight into the next experimental campaign. Every research session begins from scratch — and in ML research, that means repeating expensive computational work that has already been done.

Autoresearch: What Everyone's Getting Right (And Missing)

Karpathy's design philosophy is refreshingly pragmatic. At just 630 lines of Python, the tool is readable, hackable, and runs on consumer hardware. The agent loop is straightforward: propose a hypothesis, write the experiment code, execute it, analyze the results, and decide what to try next. This simplicity is deliberate — autonomous ML experiments should be accessible to individual researchers, not gated behind enterprise infrastructure or massive compute budgets.

These agents can iterate through dozens of experimental configurations overnight, testing architectural variations, hyperparameter sweeps, and data augmentation strategies that would take a human researcher weeks to explore manually. When Shopify's CEO demonstrated a 19% validation improvement, it validated the core thesis: AI research agents can produce genuinely useful results when given the freedom to explore autonomously. The codebase proves that agent-driven research doesn't require massive frameworks.

What's missing is cross-experiment memory. Each experimental run operates in isolation. An agent that discovered that learning rate warmup is critical for a specific architecture doesn't retain that insight for future experiments on similar architectures. Promising dead ends get re-explored. Successful patterns get rediscovered rather than retrieved. For autonomous ML experiments that run overnight, this means mornings spent reviewing results the agent has already produced — and discarded — in previous sessions. The computational cost of this amnesia grows with every research campaign.

The MemU Agentic Memory Framework: Persistent Memory for ML Research

The MemU Agentic Memory Framework provides the persistence layer that autonomous experiment tools don't include. Instead of treating each experimental campaign as an isolated event, MemU captures discoveries, failed approaches, and learned patterns into a structured memory graph that persists across runs, projects, and even research teams.

Consider an agent running overnight experiments on a new image classification architecture. Without persistent memory, it might spend three hours exploring learning rate schedules that a previous run already determined were suboptimal for this data distribution. With the MemU Agentic Memory Framework, the agent retrieves previous findings before designing its first experiment — skipping known dead ends and building on proven approaches from the very first iteration.

The framework provides three capabilities critical for autonomous ML experiments:

• Experiment history persistence: Every hyperparameter configuration, architecture variation, and training outcome is stored with full context — not just final metrics, but the reasoning behind each decision. Future runs query this history to avoid redundant exploration and prioritize promising directions.
• Cross-project knowledge transfer: Insights from one research project become available to others. The MemU Agentic Memory Framework captures transferable patterns — like which optimizers work well for specific data characteristics or which regularization techniques prevent overfitting on small datasets — that accelerate new projects from day one.
• Failure memory: Dead ends are as valuable as successes when they're remembered. The framework stores why approaches failed, not just that they failed, preventing agents from repeating expensive computational mistakes with slight variations.

In ML research, the most expensive experiments are the ones you've already run. Persistent memory ensures that no computational work is wasted — every experiment informs every future experiment, automatically.

Integration is lightweight. The MemU Agentic Memory Framework provides simple Python APIs that any research tool can call to store findings and retrieve relevant prior knowledge before starting new experiment runs. No changes to the core agent loop required — just an added memory layer that compounds research value over time.

Head-to-Head: Isolated Experiments vs. Memory-Enhanced Research

Autoresearch alone: Autonomous experimentation within session boundaries. Agents iterate through hypotheses efficiently on a single GPU, producing results that would take human researchers much longer. But each campaign starts fresh — no knowledge from previous runs transfers, and previously explored dead ends get re-explored. The hundredth experiment has no informational advantage over the first.

Autoresearch + MemU: The same autonomous experimentation, now backed by cumulative research memory. Agents start each run with full access to everything previous runs discovered. Failed approaches are automatically filtered out. Promising directions are prioritized based on prior experimental evidence. Research velocity accelerates with every experiment completed — the agent gets genuinely smarter over time, the way a human researcher accumulates intuition.

The difference compounds rapidly. After ten experimental campaigns, a memory-enhanced agent has accumulated a structured knowledge base of what works, what doesn't, and why. Session-bounded agents have ten isolated sets of results that a human must manually synthesize and cross-reference. For AI research agents running overnight on consumer GPUs, that synthesis gap translates directly into wasted GPU hours and delayed discoveries.

Empowering ML Research: Better Together

The combination of autonomous experimentation and persistent memory creates a research workflow that improves with every cycle:

• Progressive hyperparameter optimization: Instead of running grid searches from scratch, agents start with a prior distribution informed by all previous experiments. The search space narrows with each campaign, converging on optimal configurations faster than any single-session approach.
• Architecture insight accumulation: Agents that have explored dozens of model architectures build a knowledge graph of which structural patterns work for which data types. New architecture searches begin with informed hypotheses rather than random initialization.
• Team research continuity: When multiple researchers run their own agents on related problems, shared memory pools ensure that one researcher's discoveries inform another's experiments. Collaborative ML research becomes genuinely collaborative at the agent level.
• Reproducibility by default: Persistent memory creates a complete audit trail of every experiment, decision, and outcome. Reproducing results months later becomes a query, not a reconstruction project.

Karpathy demonstrated that 630 lines of Python is enough to create a capable AI research agents tool. Adding persistent memory ensures that those capabilities compound rather than reset with every new session.

Get Started with MemU

Autoresearch represents a meaningful step forward for accessible ML research — proof that autonomous experimentation doesn't require enterprise infrastructure or massive budgets. The community's rapid adoption demonstrates real demand for agents that can run experiments independently.

The next step is giving those agents memory that persists across experiments. Research that builds on itself automatically. Experimental campaigns where every run starts smarter than the last. Teams where one researcher's computational investment benefits everyone's future work.

The MemU Agentic Memory Framework provides that foundation. Lightweight Python integration means you can add persistent memory to any research workflow without rewriting existing tools. Structured knowledge graphs capture the experimental relationships that make retrieval precise. And cross-project memory sharing enables the kind of cumulative research intelligence that individual session-bounded tools cannot achieve alone.

Visit memu.pro to explore the Agentic Memory Framework API, or check out the GitHub repository to start building agents that remember.