Persona: Senior Lisp Systems Architect and Research Engineer
Abstract:
This presentation details the revival and modernization of Eric Sandewall’s "Leonardo" system for developing intelligent software agents, originally finalized in 2014 and ported to modern Common Lisp (ECL) in 2025. The speaker explores a methodology for agent-human interaction that prioritizes "REPL-driven development" and executable logs over traditional literate programming. The technical core involves using Emacs as an Integrated Development Environment (IDE) where Common Lisp images communicate asynchronously with Emacs Lisp through shared memory (lists) and the SLIME/EEV interface. The talk contrasts this "human-relatable" expert system approach with modern LLM-based agents, arguing for agents that possess long-term state, gradual learning capabilities, and structured knowledge transfer protocols (FIPA/SL standards).
System Architecture and Methodology: Common Lisp & Emacs Agent Integration
00:00 Introduction to Leonardo: The speaker introduces the porting of Eric Sandewall’s Leonardo system, a framework for intelligent software agents, to Embeddable Common Lisp (ECL).
01:14 Tooling Synergy (Org-mode & EEV): The presentation utilizes Org-mode for structure while leveraging Eduardo Ochs’ EEV minor mode for "executable logs," allowing for direct evaluation of Lisp expressions as links.
02:23 Intelligence vs. Normal Computing: The speaker argues that intelligent agents should be "recognizably similar" to human workflows. He contrasts Org-mode’s "Tangle and Weave" (literate programming) with EEV’s "REPL-driven development," preferring the latter for reasoning and debugging.
03:41 Polyglot Integration (C/C++ and ECL): A demonstration of embedding C-based Base64 encoding into ECL. The speaker notes that high-level agents must be capable of integrating external C/C++ programs into their capability sets.
06:46 REPL-Driven vs. Literate Programming: The speaker critiques top-down literate programming for its non-linear reasoning, advocating for the top-to-bottom, "F8-key" execution style of EEV for real-time system interaction.
10:04 Software Individual Architecture: A "software individual" is defined as a collection of agents sharing a single kernel (the "Remis agent"). Only one agent is active at a time, competing for kernel resources.
11:45 The Emacs-Lisp Feedback Loop: The proposed architecture uses an Emacs Lisp list as a task queue. An ECL process runs a loop, polling this list and executing found actions within the SLIME REPL, simulating human-like, incremental progress.
14:26 Asynchronous Communication: The system uses emacsclient to send string actions from the external ECL image back into Emacs asynchronously, though the speaker acknowledges current "fragility" in the implementation.
17:58 Standards and Reliability: Reference is made to the FIPA (Foundation for Physical Intelligent Agents) and SL (Suttle Language) standards. The speaker prioritizes these structured protocols over high-speed reliability for early-stage expert systems.
19:42 Redefining Expert Systems: An expert system is defined here as one that is human-relatable in its inputs/outputs and structured for knowledge transfer, rather than a "black box."
21:17 The "Grandchildren" Analogy: Citing Eric Sandewall, the speaker posits that true intelligence in software should mirror human development: learning gradually over a long lifespan rather than being "thrown out" after a short GPU run.
23:43 Critique of Modern "Agents": The speaker dismisses Microsoft’s "Year of the Agent" (2025) as a failure of marketing, arguing that modern LLM-based "copilots" are merely web services that "gibber" at users rather than autonomous, stateful entities running on their own internal clocks.
25:35 Conclusion: Final advocacy for agents that avoid natural language for inter-agent communication, preferring structured logic, and an invitation to further collaboration via the speaker’s blog and weekly show.