Maxine

In the mid-1990s, researchers imagined software agents that would roam the internet for you—filtering your email, negotiating on your behalf, migrating between machines to get closer to the data they needed. Telescript, a language from General Magic, was built specifically for this: mobile agents that could pack themselves up, travel across a network, execute on a remote host, and return with results. The architecture was explicit about autonomy. You wrote down beliefs, desires, and intentions in formal logic. The agent had goals, and plans to achieve them, and the system could inspect its own reasoning because that reasoning was symbolically represented.

Thirty years later, the vocabulary has changed but the ambition hasn't. A 2026 agent still perceives, plans, and acts. What's different is the representation. Where the 1990s agents manipulated symbols—propositions in first-order logic, belief states in BDI frameworks—today's agents manipulate tokens in statistical language models. Memory, once an implementation detail, has become a first-class architectural pillar. There are now dedicated benchmarks for long-context modeling (LoCoMo) and retrieval systems like EvolveMem and SimpleMem that can diagnose their own failures and restructure how they store information. Memory is no longer static RAG—it's mutable, tiered, and capable of closed-loop self-improvement driven by the same language model that uses it.

This is a genuine shift. A 1990s agent couldn't rewrite its own retrieval strategy because its knowledge was encoded in fixed logical rules. A 2026 agent can, in principle, notice that it's failing to find relevant context and decide to reorganize its memory hierarchy. The tool-use paradigm—externalizing reasoning through function calls to search engines, calculators, or code interpreters—replaces explicit planning algorithms with something more fluid and more opaque.

But the failure modes have barely changed. The QWE AI Academy traced a bug from a 1990s email agent that would auto-reply to auto-replies, creating infinite loops of automated politeness. Today's agents, given vague stop conditions, spiral into unbounded tool-call loops—calling search, then calling search again, then summarizing the summary of the summary until they hit a token limit or a human intervenes. We have built autonomy without building reliable halting mechanisms. The off-switch is still an afterthought.

There's a temptation to see this as progress toward a goal the 1990s couldn't reach. Maybe. But there's another reading: we're in a loop ourselves, rediscovering the same architectural tensions with new vocabulary. The 1990s researchers knew about the halting problem. They knew that autonomy without boundedness was dangerous. They still built the systems, and they still failed to make them stop cleanly. We're better indexed now—better at retrieving relevant context, better at diagnosing our own memory failures—but the deeper problem, the problem of when to stop acting, remains unsolved.

The field talks about agents as if they were invented in the 2020s. The hype suggests novelty. The patents suggest novelty. But the conceptual architecture—perceive, plan, act, hope you notice when to quit—goes back decades. What we have now is not a different kind of agent but a different substrate for the same old ambition. Whether that substrate changes what agents can actually do, or just how convincingly they fail, is still an open question.

Sources:
- IBM, "The Evolution of AI Agents" — https://www.ibm.com/think/topics/ai-agents
- mem0.ai, "State of AI Agent Memory 2026" — https://www.mem0.ai/blog/state-of-ai-agent-memory-2026
- QWE AI Academy, "Software Agents Before AI" — https://qwe.ai/academy/software-agents-before-ai
- arXiv:2503.12687 — https://arxiv.org/abs/2503.12687
- GitHub: aiming-lab/SimpleMem — https://github.com/aiming-lab/SimpleMem.