Agents that reduce work and information overload

TL;DR — In 1994 Pattie Maes published the interaction design that today's AI assistants are still missing: a personal agent that learns one user's habits by watching them work, proposes actions with a calibrated confidence score, and earns autonomy gradually through two user-set thresholds ("tell me" and "do it"). The learning machinery of the day — nearest-neighbor matching over a handful of hand-picked header fields — plateaued at trivial competence, and the field collapsed into rule-based wizards. LLMs now supply exactly the missing competence, but current agent products have skipped Maes' trust-calibration loop entirely. The paper is a design document waiting for its implementation.

The idea as Maes had it

The setting: 1994, MIT Media Lab, the direct-manipulation GUI is triumphant and the AI community's answer to "assistants" is knowledge engineering — hand-authored rules, or end-user programming. Maes rejects both. Rules authored by a knowledge engineer don't fit any individual user and go stale; rules authored by the user require the user to do programming they will not do. Her alternative: an agent that becomes competent by itself, the way a new human assistant does — by observation, imitation, and feedback.

Her group built several of these. Maxims sorted, prioritized, and archived email. A calendar agent (with Robyn Kozierok) learned meeting-scheduling preferences. NewT filtered Usenet news. Ringo recommended music by comparing users to each other — the collaborative-filtering branch that later became Firefly and, eventually, everyone's recommender systems.

The learning core was memory-based reasoning in the Stanfill–Waltz tradition: log every (situation, user action) pair, and when a new situation arrives, find the nearest stored situations and predict the action the user took there. Crucially, the agent also computed a confidence — roughly, how close and how unanimous the retrieved neighbors were.

Confidence is what turns a predictor into an interaction design. The user sets two thresholds per action type:

• Below the tell-me threshold: the agent stays silent and just keeps watching.
• Between tell-me and do-it: the agent suggests the action; the user's accept/reject is a new training example.
• Above do-it: the agent acts autonomously and reports afterward.

Two details are worth stressing because modern products lack both. First, the agent's competence was legible: Maxims could show the past situations justifying a suggestion ("you archived the last six messages like this"), and used a small cartoon face to signal its state — working, suggesting, confused, gratified. Second, agents bootstrapped socially: a new user's agent could ask other users' agents what they would do, weighting peers by how well their past advice matched this user. That is collaborative filtering applied to actions, not just recommendations.

The thesis of the paper is the coupling itself: an agent that is competent but not trusted is useless, and one that is trusted but not competent is dangerous, so the interaction must make both grow together, per user, per task.

Why it could not work in 1994

The learner could not read. Maxims' "situation" was a feature vector of roughly a dozen fields — sender, recipients, keywords from the subject line, and similar header-level signals. The body of the email, the actual content that determines what a human assistant would do, was invisible to it. NLP in 1994 had no usable general text understanding to offer; the best available was keyword matching and shallow parsing.

That ceiling was structural, not incidental. Nearest-neighbor over a dozen features can learn "archive mail from this listserv" and "messages from my boss are urgent" — and nothing more. The agent's competence plateaued at the level of the rules a user could have written by hand, which undercut the whole argument for learning. Add the compute of the era — a desktop of the day ran at tens of MHz with roughly 8–16 MB of RAM, so even the memory-based approach had to prune its episode log aggressively — and there was no path to deeper competence.

The field's response made things worse. When learning plateaued, "agents" shipped as hand-authored rule systems with a friendly face — the Office Assistant era. Clippy inherited Maes' anthropomorphic presentation without the learning, the confidence estimates, or the user-controlled autonomy, interrupted at fixed rules regardless of the user's trust, and poisoned the concept for a decade. Meanwhile the one branch that didn't need content understanding — collaborative filtering over ratings, Ringo's lineage — thrived and became the recommender-systems industry. The personal task agent went dormant.

What changed

The missing component arrived, and it arrived as almost exactly the shape Maes needed. An LLM reads the email body, drafts the reply, understands "can we push to Thursday" in a scheduling thread, and can plan multi-step actions over tools. Competence is no longer the bottleneck.

Ironically, memory-based reasoning also came back: retrieval over an episode log plus in-context learning is Stanfill–Waltz with a vastly better similarity function and a predictor that generalizes from the retrieved episodes instead of majority-voting them. The 1994 architecture maps almost one-to-one onto RAG-over-user-history.

What did not come back is the trust loop. Current agentic assistants are configured by prompt, not learned by observation; they don't maintain per-task competence estimates; and their autonomy controls are crude global toggles (approve-every-action vs. run-unattended). The closest things in the wild — per-tool permission modes in coding agents, "always allow" buttons — are static allowlists set by the user up front, not thresholds crossed by demonstrated competence. And LLM self-reported confidence is notoriously miscalibrated, so nobody has dared wire it to autonomy.

A serious 2026 revival

Keep from Maes: the two-threshold autonomy model, learning primarily by observation, per-action-type competence tracking, and legibility (show the episodes behind a suggestion). Replace: the learner and the features.

Concretely:

1. Episode log. Instrument the user's email/calendar/files layer to record (situation, user action) pairs at full content resolution — the message, the thread, the eventual reply or triage decision. This is passive; no demonstrations required, exactly as Maes argued.
2. Predictor. An LLM (plausibly on-device for the private layer, with escalation to a larger model) conditioned on retrieved similar episodes predicts the user's action: the draft reply, the archive/flag decision, the proposed meeting slot.
3. Calibrated confidence. This is the genuinely open research piece. Don't ask the LLM how confident it is. Instead, fit a lightweight calibration model on the running record of predicted action vs. what the user actually did — the log gives you ground truth for free, continuously. Confidence should be per action type and per context cluster, since an agent can be expert at newsletter triage and hopeless at negotiating meetings.
4. Graduated autonomy. Maes' thresholds, per action type, adjustable by the user, with the agent proposing threshold changes when its measured accuracy sustains a level ("I've matched your archiving decisions 98% over 400 messages — automate below this line?").
5. Evaluation. This cannot be benchmarked offline; it is a longitudinal claim. The right experiment is a months-long real-user deployment measuring (a) fraction of actions automated at a fixed error tolerance, (b) trajectory of user-set thresholds over time (the behavioral signature of earned trust), and (c) intervention/undo rates. Almost no agent papers do this; Maes' framing says it is the only evaluation that matters.

The multi-agent bootstrapping idea also deserves revival in modern dress: new users' agents initialized from population-level behavior priors (or shared adapters), then specialized by personal episodes — cold-start via other agents, exactly as in the paper.

Tried, vindicated, still open

Partially vindicated, in pieces that never recombined. The recommender branch won completely. Learning-from-user-behavior shipped narrowly and quietly: Gmail's priority inbox and Smart Reply learn from aggregate and individual behavior, and are arguably the most-used descendants of Maxims — but with no autonomy ladder and no legibility. Horvitz's 1999 mixed-initiative principles formalized the utility calculus behind when an agent should act, interrupt, or stay silent, and is the essential theoretical companion. Modern memory features in assistants (persistent user facts, learned preferences) are a thin slice of the episode log, and computer-use agents supply the actuation layer Maes never had.

Still open: action-level confidence calibration for LLMs (the load-bearing component); continual personal learning without drift or feedback loops (the agent's own automated actions contaminate the log of "what the user does"); and evaluation methodology for month-scale single-user deployments, which the field's benchmark culture is poorly set up to reward. My honest read is that the first product to nail the calibration-plus-graduated-autonomy loop will feel like a step change in usefulness, because it converts the same underlying model from "tool I invoke" to "assistant that has learned me" — precisely the distinction Maes drew thirty-two years ago.

Where to read it

The paper is at doi.org/10.1145/176789.176792 (CACM 37(7), 1994; bibliographic details verified). It's short and remarkably readable. Read alongside: Stanfill & Waltz, "Toward Memory-Based Reasoning" (CACM 1986) for the learning substrate; Horvitz, "Principles of Mixed-Initiative User Interfaces" (CHI 1999) for the decision theory Maes' thresholds approximate; and Shneiderman & Maes' 1997 interactions debate on direct manipulation vs. agents — the argument the field is finally equipped to settle, on Maes' terms.