Abstract
In the early development of software agents, the primary bottleneck was the complexity of low-level system programming. This paper introduces SodaBot, a pioneering framework that treats agent development as an operating system design problem. By implementing a "Basic Software Agent" (BSA) as a specialized OS and a high-level language called SodaBotL, the system abstracts away messy low-level protocols. This two-tier architecture enables the creation of portable, complex agents for tasks such as personal assistance and meeting scheduling without requiring developers to manage network sockets or mail protocols manually.
Introduction
In the early 1990s, software agent research was polarized between high-level theoretical models of agent intentions and low-level, one-off implementations. The "agent construction process" served as the primary bottleneck; building a functional agent required extensive "system-hacking" to manage mail protocols, network sockets, and site-specific dependencies. These requirements made agents fragile, difficult to install, and nearly impossible to distribute across different environments. SodaBot was developed to allow researchers to build agents quickly by removing the need to engage with the digital plumbing of Unix system calls.
System Architecture
The SodaBot environment utilizes a two-tier architecture to decouple agent logic from system implementation:
- The Basic Software Agent (BSA): This acts as an "agent operating system." It is a generic computational framework that runs in the background on a user's workstation. Much like a traditional OS, it uses a time-sharing algorithm to run multiple agent programs simultaneously and manages the interface between those programs and the underlying hardware and network.
- SodaBotL (SodaBot Language): This is a high-level programming language designed specifically for agent activity. SodaBotL provides "human-level" primitives. Instead of writing code to open a socket or parse an email header, a developer writes commands like
Get Response(with built-in timeouts) orWait until(to handle temporal events).
This abstraction layer ensures that agent programs are no longer "hard-coded" to specific local parameters, making them inherently portable across different workstations.
Key Insights and Ideas
- The OS Abstraction: The most significant innovation is the realization that agents should not be standalone applications but rather scripts running on a specialized virtual machine (the BSA). This shift from "building an agent" to "programming an agent environment" solves the portability crisis.
- Declarative Control Structures: SodaBotL moves away from imperative system-level logic toward declarative, intent-based logic. The language handles the complexity of temporal events (e.g., "waiting until Tuesday") or user interaction (e.g., "prompting a user and waiting 10 minutes") as first-class primitives.
- Decoupling for Distribution: By disconnecting the agent program from the specific computational environment, SodaBot allows for the "automatic distribution" of agents. A user can receive an agent programmed by someone else, and it will run on their BSA without needing manual reconfiguration of local mail or network settings.
Results and Discussion
While the initial work focused on system description rather than quantitative benchmarks, several qualitative milestones were achieved. SodaBot was fully implemented and tested at the MIT Artificial Intelligence Laboratory. The system successfully demonstrated that SodaBotL could abstract away Unix-specific complexities like system calls, mail servers, sockets, and X-windows, resulting in significantly shorter and more readable agent code.
However, the system presents certain limitations for future exploration. The BSA is designed to run programs provided by others, which in a modern context raises significant security and sandboxing concerns. Additionally, while the BSA uses a time-sharing algorithm, the scalability of simultaneous agents on 1990s-era hardware remains a question for further study.
Conclusion
SodaBot represents a significant step toward making software agents a practical reality by simplifying their construction. By providing a robust environment (the BSA) and a specialized language (SodaBotL), the system allows developers to focus on agent behavior rather than system-level implementation, paving the way for more complex and portable agent-based applications.
Summary updated