MIT Course MAS.S62: Two Lectures on the Evolution of Harnesses and Multi-Agent Systems

MIT course MAS.S62 "How to AI an AI": four layers of evolution — prompt optimization, harness evolution, model self-play, and task generation

@pliang279's Lectures 4-5, two consecutive lectures on "Harness evolution," are strongly recommended reading and study; they cover Harness Evolution (harness components, memory, tools, and skill evolution) and Multi-Agent Evolution (planning, task decomposition, multi-agent systems, and evolution), respectively.

# Lecture 4: First dissect the Harness, then talk about letting it evolve https://t.co/4emiLkozt1

Memory section: a three-axis taxonomy + four representative systems. The lecture notes use three axes to organize the entire memory research space: what is stored (feedback/skills/trajectories/semantic facts), how it is represented (text/structured/multimodal/parametric), and where it is stored (context/parameters/external), plus how it is reused (retrieval/adaptation/composition/transfer).

Then, along "where it is stored," four systems are laid out: · @MemGPT (external memory): analogizes the LLM to an operating system, turning memory reads and writes into the agent's own function calls; · @mem0ai (external memory): structures memory as an entity-relation triple graph, supporting four operations: add/update/delete/noop; · MEM1 (in-context memory, from the instructor's own group): this is the part this lecture dwells on most. Addressing the problem that "the reasoning context keeps growing, causing complexity and forgetting," MEM1 has the model generate at each step an internal state that integrates reasoning and memory, then discards all history; the context size stays constant, and the model can be trained end-to-end with outcome rewards to learn "compression." Experiments show three emergent behaviors: categorizing and storing the key information of each question, updating memory after finishing one question before moving to the next, and learning to skip a question after multiple failed searches. None of these behaviors was explicitly programmed. · Reflexion / ExpeL (experiential memory): trajectories are stored in short-term memory and self-reflections in long-term memory; ExpeL further stores feedback on "whether this experience is useful."

Context Language Models (CLM) close out the memory section: the model treats its entire context as a file, edits it freely with Bash commands, and edits are synchronized with the real context; creating/deleting context files instantiates/terminates sub-agents; memory, context management, and multi-agent structure are unified into "file operations."

Tools and Skills section: the lineage from Toolformer to Meta-Harness is: Toolformer (the model self-learns single-step tool calls) → ToolLLM (extended to multi-step, 16,000+ APIs) → CodeAct (key claim: code is a meta-tool; a single action can compose control flow, libraries, and multiple operations; experiments show that using code for tool calls yields the highest success rate and the fewest interaction turns) → the Skills layer: Skills can be represented as text or code (the latter is more composable), can serve as abstract classes in code (PolySkill), and can be induced from successful and failed trajectories into reusable workflows (Agent Workflow Memory) → Voyager's Skills library (automatic curriculum generation + environment feedback + Skills induced into the library).

The finale, Meta-Harness, brings the lecture to its peak: existing LLM optimization methods show the optimizer only "brief summaries, scalar scores, and partial historical candidates," whereas the harness is far more complex. Meta-Harness represents the entire harness as a file system, with the complete source code, scores, and all execution trajectories placed inside, letting the proposer (Claude Code, reading with grep/cat) trace failures back to specific harness decisions; the feedback information is nearly 400 times that of prior methods (10 million tokens vs. 26,000). Prompts, RAG, Skills, tools, memory, and program loops are all unified as optimizable objects in the file system.

Commonalities: simple, no manual design, end-to-end; the objects that can be autonomously optimized keep rising in dimension along "memory → context → harness"; and the same paradigm scales across zero-shot, in-context learning, and fine-tuning modes. This is the most condensed expression of the course's "self-evolution" idea: rather than making AI stronger at some single point, continuously expand the boundary of "what can be rewritten by AI itself."

# Lecture 5: From planning to multi-agent, turning mysticism into empirical science https://t.co/9MfFAfLJV3

Planning section: three key questions. The lecture first clarifies the core questions of planning: when is planning useful, and when is it harmful? How should plans be represented? When should a plan be changed? The conclusion is clear: prompt-based planning (CoT, Least-to-Most) is suitable for scenarios that are pure text, have no side effects, and are reversible; once a plan acts on the real world, changes the agent's state, and is irreversible, it must "plan-execute-observe-replan." The subsequent cases show a spectrum: division of labor between large and small models (a large model plans + a 7B model executes GUI actions), human-in-the-loop clarification of uncertainty, training a planner on synthetic data, sampling multiple plans to estimate uncertainty (calibrated planning), and "Thinking vs Doing," where at test time the model does not just think, but actually executes, looks at feedback, and retries.

Multi-agent section: five empirical findings. This part takes Towards a Science of Scaling Agent Systems (Nature Machine Intelligence 2026) as its main thread. The lecture does not stop at the popular narrative that "multi-agent is more powerful," but instead gives five sober empirical conclusions: 1. Multi-agent is only effective for specific task structures. Financial agent tasks are naturally decomposable (revenue/cost/market), and MAS wins 81%; PlanCraft-type tasks have strong sequential dependencies, and splitting instead hurts, with MAS losing 70%. Guideline: parallelizable → centralized; requires exploration → decentralized; sequential dependency → single agent. 2. Gains vary with the base model: OpenAI models increase in cost while performance plateaus; Google models have high cost and high performance; on Anthropic models, MAS may even harm performance. 3. More agents is not necessarily better: tool-intensive tasks (workflows with 16 tools) are dragged down by coordination overhead, and the penalty compounds with environmental complexity. 4. Heterogeneous mixtures can beat a stronger single base model: there is no need to use expensive models everywhere; "cheap orchestrator + expensive executor sub-agents" is a useful configuration; and if the single-agent baseline already exceeds 45%, MAS is instead harmful. 5. Performance is predictable: a scaling law parameterized by model, task, and MAS configuration can predict the optimal architecture with 87% accuracy, moving from "trying configurations by luck" to a principled science of agent design.

Together with "Why Do Multi-Agent LLM Systems Fail?" in the reading list, these five findings constitute the course's empirical correction to the multi-agent hype.

Multi-agent evolution: CORAL. Since the design space of multi-agent systems (task, base model, topology) is so sensitive, the next step is to let it evolve autonomously; there are three levels of objects that can evolve: individual agents (model/context/harness), system structure (roles/communication/topology), and shared information (public memory/tools/Skills). The representative work CORAL (a first-author paper by this course's TA Ao Qu): multi-agent specialization, high autonomy, shared memory, and a heartbeat mechanism to maintain continuous operation; it achieves new SOTA on 8 tasks including mathematics, algorithms, and system optimization, and multi-agent evolution brings 4%–20% improvement over single-agent. Its analysis answers "why co-evolution is useful": 36% of evolution attempts use other agents as parent nodes, and these attempts have a 17% improvement rate (versus 9% on average); cross-agent information transfer is the real source of gains; the overlap in exploration directions across agents is low (Jaccard 0.3–0.4, with more than half of explorations being unique); contributions are balanced, with no free riders.

# Looking at the two lectures together: where is the boundary of autonomous optimization?

Lecture 4 advances along "object dimensionality elevation": memory → context → the entire harness (files → file system), each level handing a larger piece of the system to the LLM for autonomous rewriting;

Lecture 5 advances along "system dimensionality elevation": individual agent planning → multi-agent orchestration → evolution of the multi-agent system itself (roles/topology/shared memory), each level handing a larger design space to autonomous search.

And both lectures maintain the same critical restraint: Lecture 4 emphasizes that only "simple, no manual design, end-to-end" can scale, while Lecture 5 repeatedly reminds us with five empirical findings that "multi-agent is not a free lunch." First establish a rigorous taxonomy and empirical laws, then hand the remaining design space to autonomous evolution—this is both the pedagogical structure of these two lectures and the methodological answer this course gives to the meta-question of "how to research self-evolving AI."