ACLT is coordination mode, then tuned into a real coordination system, developed between 1995 and 1999.
This system is no longer supported, since newer, Java-based systems, which include the main ACLT ideas, were developed inside the LuCe project and more recently inside the TuCSoN project.

Below you can find some information about ACLT in its golden days; for further information, please refer to the contact persons in the LuCe or TuCSoN projects.

The ACLT coordination model (first presented in AI*IA'95) aims to provide intrinsic support for intelligent coordination of multi-component distributed software systems, such as multi-agent systems. It is based on a shared communication abstraction à la Linda [Linda Team at York University, Yale Linda Group], which is however strongly enhanced according to the model's goals. In particular, ACLT's tuple spaces are

• multiple - a multiplicity of tuple spaces can be exploited by any ACLT agent as independent communication channels
• named - each tuple space can be referred directly through its name, which is a constant (a logic ground term), independently of both agent and tuple space location on a network
• logic - tuples are logic atoms, so that the communication channel can be conceived also as a theory of the communication
• reactive - observability is lifted up from communication state changes to communication events, so that tuple spaces are reactive to communication events too
• programmable - tuple space's reactions to communication events can be defined through a logic tuple-based language called ReSpecT

As discussed in FroCos'96 (where a reference architectural model is presented), ACLT's logic tuple spaces intrinsically support agent heterogeneity. In fact, they make it possible for agents which are heterogeneous from the conceptual, the architectural and the technical viewpoints to coordinate and cooperate, since each agent can perceive the coordination device at the abstraction level which best fits its specific role in the overall architecture - i.e., as a logic tuple space (with unification) for logic agents, and as a conventional tuple space (with pattern matching) for non-logic agents.
In particular, a logic tuple space can be interpreted by a logic agent as a logic theory of the communication, where logic proofs can be performed over the communication state. For this purpose, ACLT provides a family of demo primitives (AI*IA'95), which make the typical logic view of platonic, immutable truth coexist with the time-variant view of tuple spaces.

The concept of reactive tuple space is introduced in Coordination'96, where the notion of extensible communication abstraction (a communication abstraction whose behaviour can be defined according to the system's goals) is exploited so as to provide both an extensible communication kernel, and the ability to build application-defined development tools.
A revised, full-featured reaction framework is then presented in Coordination'97, where the notion of Programmable Coordination Medium is first introduced, and ACLT's tuple spaces are interpreted as instances of that general notion. This provides a new notion of system extensibility, which seems particularly suited to component-based technology. In particular, the impact of this notion on the design of multi-agent systems is discussed in ModelAge'97. The syntax and semantics of the ReSpecT reaction language is presented in LIA-97-009, and its computational and expressive power is discussed in SAC'98. .