From Bayes to Your Agents: A Short History of Machine Learning

Machine learning feels like it arrived overnight. One day we were impressed by spell-check; the next, large language models were writing code and arguing about philosophy.

But the real story is two and a half centuries long. It starts with a pastor reasoning about uncertainty, runs through chess champions and cat videos, and lands on a problem most people still ignore:

Models keep getting smarter. They still don’t remember you.

This is the history of machine learning, and why the next breakthrough won’t be a bigger model. It will be a memory layer that follows you across every app, agent, and device you use. That layer has a name, and it’s about to reach its next milestone: Ditto v2.

1763: The Probability Revolution

Long before computers, Thomas Bayes laid the groundwork for machine learning. His theorem gave us a way to update beliefs as we see new evidence.

That idea, start with a guess, then refine it with data, is still the heartbeat of modern AI. Every spam filter, recommendation engine, and language model relies on some form of probabilistic reasoning.

Machine learning did not begin with neural networks. It began with uncertainty.

1950s: Machines That Learn

Alan Turing asked the right question first: can a machine learn?

In 1950 he proposed a “learning machine” that could become intelligent through experience. A few years later, Arthur Samuel built checkers programs that improved by playing themselves and coined the term “machine learning” in 1959.

Frank Rosenblatt’s 1957 perceptron was the first trainable neural network. It was simple, exciting, and limited. In 1969, Marvin Minsky and Seymour Papert published Perceptrons, exposing those limits and helping trigger the first AI winter.

The lesson: promising beginnings don’t guarantee useful systems.

1980s: Backpropagation Brings Neural Nets Back

The field thawed in 1986 when researchers made backpropagation practical. For the first time, multi-layer neural networks could be trained efficiently.

This was the quiet hinge of modern AI. The algorithms that would later power image recognition, speech synthesis, and language models were now possible in principle. They just needed data, compute, and another few decades of engineering.

1990s to 2000s: From Knowledge to Data

Machine learning shifted from hand-coded rules to data-driven models. Support vector machines, random forests, and kernel methods dominated.

In 1997, IBM’s Deep Blue beat Garry Kasparov at chess. It was a milestone, but also a warning: brute-force search and specialized hardware could look intelligent without understanding much.

The real infrastructure was being built elsewhere. In 2009, Fei-Fei Li’s team released ImageNet, a massive labeled image dataset. The field finally had fuel.

2012: Deep Learning Arrives

AlexNet crushed the ImageNet competition. The trick was deep neural networks trained on GPUs. Deep learning went from academic curiosity to industry standard almost overnight.

Soon, machines recognized faces, translated languages, and drove cars. But these systems were still pattern matchers. They processed input, produced output, and forgot everything.

2017: Attention Changes Everything

Google Brain’s transformer architecture made parallel training on sequential data practical. The paper Attention Is All You Need became one of the most cited in AI history.

Transformers led to GPT, BERT, and the entire foundation-model wave. They made long-context conversation possible. But context is not memory. It is a wider short-term window, not a long-term record.

2022: ChatGPT Makes AI Mainstream

When OpenAI released ChatGPT, conversational AI became a household product. Millions of people discovered both the power and the frustration of modern AI: brilliant answers, zero recall.

Close the tab and start again. Upload a file, explain your project, build context over an hour, then lose it all because the model has no persistent memory.

This is not a bug. It is an architectural gap.

The Gap History Keeps Ignoring

Every major chapter in ML history improved one thing: the model’s ability to recognize patterns in the current input.

• Bayes gave us inference.
• Neural networks gave us function approximation.
• Deep learning gave us rich representations.
• Transformers gave us coherent long-context generation.

What none of them solved was continuity. Each conversation is a fresh start. Each agent works in isolation. Your context lives in a dozen separate chat histories, none of which talk to each other.

A context window is a window: wide, but temporary. Memory is a library. It grows, it survives sessions, and it connects ideas across everything you’ve ever discussed.

The next chapter isn’t about building a bigger brain. It’s about giving that brain a memory that persists across sessions, models, and tools.

Why Memory Is the Next Frontier

Real memory is more than a list of facts stored in a settings panel. It has to be:

• Continuous: it follows you across conversations, not just within one.
• Connected: it links ideas, projects, and people into a knowledge graph.
• Visible: you can see what is remembered, search it, and correct it.
• Portable: it moves with you, independent of any single model provider.
• Agent-aware: every agent and sub-agent you use can draw from the same context.

This is exactly what Hey Ditto is building.

Ditto: The Memory Layer for Your Agents

Ditto is not another chatbot. It is the memory layer that sits between you and the models you use.

You talk to GPT-5, Claude, Gemini, or Ditto’s own agents. Ditto remembers the important parts, organizes them into a personal knowledge graph, and surfaces the right context when you need it. Threads keep project context scoped. Sub-agents act with that context already built in. MCP connectors let your memory talk to Gmail, Slack, GitHub, Google Workspace, and more.

The models change. Your memory does not have to.

Your Memory, Visualized

Ditto doesn’t just store conversations. It extracts subjects (people, projects, technologies, ideas) and connects them into an interactive knowledge graph.

That happens through what we call the dreaming pipeline: a memory-consolidation process, loosely modeled on how your brain weaves the day into long-term memory while you sleep. Ditto replays new conversations, extracts the subjects that matter, deduplicates them against what it already knows, and links everything into the graph.

The result is searchable, explorable, and accessible to any connected agent through MCP. Ask about “OAuth” and Ditto knows it is linked to “Firebase Auth” and “API Security” in your graph, so it pulls the right context, not just any mention of the word.

Writing the Next Chapter of ML History

Here’s the part that ties the whole story together: the field that gave us Bayes, backprop, and transformers is still moving, and Ditto is contributing to it.

Storing memories is easy. Finding the right one from a vague question is the hard research problem. When you ask Ditto something indirect, like “what did I decide about that thing a while back?”, there’s no keyword to match on, just a fuzzy query against a haystack of everything you’ve ever told it.

So we did the most machine-learning thing there is: we ran the experiment. Our Seed Memories v4 research pairs a subject-graph signal with a tiny per-user adapter, a small network that learns the shape of your memory. Together they lift Recall@1 by 7.6 points, train on a CPU in seconds, and stay under a megabyte per user.

The lesson rhymes with 1763: better memory isn’t about scale. It’s about grounding. Personalized retrieval, built on a shared encoder, is the difference between an assistant that has your memories and one that can actually find them.

Memory That Does Things

A memory you can only read is a notebook. Ditto’s is a workshop.

With Ditto Code, an agent can take what it already knows about you and your projects and build: spinning up real web apps, dashboards, and documents, deploying them to a live URL, and committing code back to your GitHub. Because the agent shares your memory, you don’t re-explain your stack every time. It picks up where you left off.

That’s the shift the last decade of ML pointed toward: not just models that recognize patterns, but agents that act on your context, and remember what they did.

Memory You Own

There’s one more requirement history teaches us to take seriously: continuity you control.

Models will keep churning. Providers rise and fall. So your memory can’t be locked inside any one of them. Ditto’s Memory Passport makes your memory portable and yours: exportable, inspectable, and interoperable rather than trapped in a walled garden.

We’re taking that further with DittoBench and the open-source Ditto Harness, the scoring core of a Bittensor subnet (SN118) where independent miners compete to build the best agent-and-memory harness. The point is resilience: a memory layer that doesn’t depend on the fortunes of any single model lab.

What This Means for You

If you are a developer, you stop re-explaining your stack to every new chat. If you are a researcher, you stop losing track of papers, hypotheses, and dead ends. If you are a founder, you stop rebuilding investor context every week. If you are a neurodivergent knowledge worker, you stop paying the cognitive tax of managing context yourself.

The job of AI is to remember the boring stuff so you can think about the hard stuff.

Ditto v2: Where It All Comes Together

Every chapter of this story has been a piece of the same puzzle. Inference. Representation. Generation. Continuity. Personalization. Action. Ownership.

Ditto v2 is where those pieces converge into something bigger: an agentic operating system. Not an app you open now and then, but a layer that runs wherever you do, across your apps, surfaces, and devices, with every agent drawing from the same persistent memory. The knowledge graph, the dreaming pipeline, per-user retrieval, agents that build, MCP connectors, a portable Memory Passport, and a model-agnostic harness, all in one place. Ditto, everywhere.

For two and a half centuries, every breakthrough made the model smarter. Ditto v2 is the one that finally gives it a memory of its own, and puts that memory everywhere you work.

The models will keep changing. Your memory, and everything built on it, won’t have to.

---

Ready for an AI that actually remembers? Sign up for Ditto. It’s free to start, works with the models you already use, and never makes you re-explain yourself.