“Give Agents their Artifacts”: The A&A Approach for Engineering Working Environments in MAS

Reference: Ricci, Viroli & Omicini (2007). “Give Agents their Artifacts”: The A&A Approach for Engineering Working Environments in MAS. Proc. 6th Int. Joint Conf. on Autonomous Agents and Multiagent Systems (AAMAS’07), Honolulu, Hawai’i, May 14–18 2007, pp. 601–603. IFAAMAS, ISBN 978-81-904262-7-5. University of Bologna (Cesena). PDF. Indexed in the ACM Digital Library.

Summary

This short paper introduces A&A (Agents and Artifacts), a conceptual meta-model for directly modelling and engineering the working environment of a cognitive multi-agent system as a dynamic set of artifacts organised into workspaces. Drawing on theories from the human sciences — Activity Theory and Distributed Cognition, and related fields such as CSCW and HCI — the authors argue that, just as humans depend on tools and artifacts to carry out cooperative (especially social) work, cognitive MAS can greatly benefit from a first-class notion of working environment composed of artifacts that agents dynamically construct, share and use. Artifacts are passive, function-oriented entities — explicitly designed by MAS engineers to encapsulate some intended purpose — and are not autonomous or pro-active; they divide broadly into resources (sources/targets of activity) and tools (instruments used to achieve an objective). A&A is deliberately orthogonal to the agent’s cognitive model: agents are treated simply as autonomous entities executing activities through internal actions, communicative actions (direct agent-to-agent messaging via some ACL), and pragmatical actions (constructing, sharing and using artifacts).

The artifact abstraction is characterised by two elements. The usage interface is the set of operations and observable states/events an artifact exposes so agents can use it: an agent acts by triggering operations and perceives by observing the artifact’s state evolution — mimicking, e.g., a coffee machine’s buttons, displays and output. The artifact manual is a machine-readable description of the artifact’s function, its usage interface, and its operating instructions, so that cognitive agents in open MAS can reason about which artifacts are useful and how to use them effectively. Workspaces act as logical containers that give the working environment a topology and a notion of locality (which artifacts an agent can observe and use).

The paper then sketches prototyping technologies built on the abstract model. CARTAGO (Common ARtifact Infrastructure for AGent Open environments) is a Java framework offering an API to define new artifact types (by extending a base Artifact class), an API for agents to create and interact with artifacts and workspaces, and a runtime that functions as a virtual machine for working environments — managing artifact life-cycles and routing observable events. CARTAGO is designed to be integrated with existing cognitive agent platforms (Jason, 3APL, Jadex, JACK, JADE), which the authors note typically lack a genuine notion of environment; a companion framework, simpA, extends CARTAGO with agent support for building full applications. The work generalises the authors’ earlier notion of coordination artifacts (AAMAS’04) and situates A&A within the Agent-Oriented Software Engineering (AOSE) agenda that treats the environment as a first-class engineering dimension of MAS.

Key Ideas

A&A meta-model: engineer the MAS working environment as artifacts organised in workspaces, as a peer abstraction alongside the agent.
Artifacts are passive and designed: they encapsulate a function (“intended purpose”), split into resources vs tools; only agents are autonomous and pro-active.
Usage interface: the operations plus observable states/events an artifact exposes — agents act by triggering operations and perceive by observing state changes.
Artifact manual: a formal description of function, usage interface and operating instructions, letting cognitive agents in open MAS select and use unfamiliar artifacts.
Workspaces: logical containers that impose topology/locality on the working environment.
Three kinds of action: internal, communicative (ACL messaging), and pragmatical (create / share / use artifacts) — the artifact dimension is the pragmatical, non-communicative half of interaction.
Orthogonal to the agent architecture: A&A integrates with heterogeneous cognitive agent platforms rather than prescribing one.
CARTAGO: a Java infrastructure and runtime (a VM for working environments) hosting artifacts; simpA adds agent support for standalone applications.
Lineage: generalises the authors’ earlier coordination artifacts; part of the “environment as first-class citizen” line in AOSE.

Connections

Agents and Artifacts — this paper is a canonical statement of the A&A meta-model.
Coordination Artifacts — the earlier notion (Omicini, Ricci, Viroli et al., AAMAS’04) that A&A generalises.
CARTAGO — the reference Java infrastructure/runtime introduced here.
Working Environment — the core abstraction A&A makes first-class in MAS engineering.
On Agent-Based Software Engineering — Jennings’s AOSE stance; A&A operationalises the environment dimension it calls for.
Agent-Oriented Programming — Shoham’s agent abstraction, which A&A complements with a peer artifact abstraction.
An Interaction-oriented Agent Framework for Open Environments — kindred work on frameworks for open MAS environments.
Multi-Agent Systems — the field-level hub.
Agent Infrastructure — CARTAGO as MAS runtime/infrastructure.
Agent Architecture — A&A is orthogonal to the cognitive architecture but pairs with concrete agent platforms.
Jason — one of the cognitive agent platforms CARTAGO is meant to integrate with.
Agent Communication Languages — communicative actions ride on ACLs; artifacts capture the complementary pragmatical interaction.
Generative Communication in Linda — the tuple-space coordination lineage from which the authors’ coordination-artifact work descends.

Conceptual Contribution

Claim: A multi-agent system should be engineered with a first-class working environment — a designed, dynamic set of artifacts organised in workspaces — as a peer abstraction to the agent, rather than treating “environment” as a monolithic given. Encapsulating function in passive, usable, inspectable artifacts systematises how agents coordinate and get work done.
Mechanism: the A&A meta-model (artifacts in workspaces, each exposing a usage interface and a manual) together with CARTAGO, a Java runtime/VM that hosts artifacts and provides APIs both for defining artifact types and for agents to use them, integrable with existing agent platforms.
Concepts introduced/used: Agents and Artifacts, Coordination Artifacts, CARTAGO, Working Environment, artifact usage interface, artifact manual, workspaces, resources vs tools.
Stance: conceptual framework / engineering (AOSE)
Relates to: generalises the authors’ Coordination Artifacts (AAMAS’04); operationalises the environment dimension of Jennings’s AOSE; complements the agent abstraction of Agent-Oriented Programming; the coordination lineage traces to tuple-space models like Generative Communication in Linda.

Backlinks

index

Linked Pages

Generative Communication in Linda

Reference: Gelernter, D. (1985). Generative Communication in Linda. ACM Transactions on Programming Languages and Systems (TOPLAS), 7(1), pp. 80–112. (Companion: Carriero, N. & Gelernter, D. (1989). Linda in Context. Communications of the ACM 32(4), pp. 444–458.) DOI · Open access PDF (UCSD)

Summary

Gelernter introduces Linda, a coordination model for parallel and distributed programming organised around tuple spaces rather than message passing. A tuple space is a logically shared, content-addressable bag of tuples; processes communicate by writing tuples into the space (out), reading them with associative pattern matching (rd, in), and creating new processes through tuple-space operations (eval). The four operations — out (write), in (consume on match), rd (read on match without consuming), and eval (turn a tuple into a live computation) — together comprise the entire coordination language. Linda is generative in that produced tuples have an existence independent of the producer: once out is invoked, the tuple lives in the space and can be matched by any process at any time. This decouples senders from receivers in space, time, destination, and form — the four “dimensions of decoupling” Gelernter argues are essential for scalable parallel programming. The model is embedded: Linda is a coordination language designed to be combined with any host computation language (the original implementations were C-Linda and Fortran-Linda). The headline architectural claim is the separation of computation and coordination: a parallel program is a computation (algorithmic logic) plus a coordination (how concurrent activities synchronise and communicate); Linda provides the coordination layer in a way that is largely orthogonal to the host language. Linda directly inspired JavaSpaces (1998), TSpaces (1999), and the Klaim mobile-agent extension; it is the conceptual root of a substantial sub-tradition of coordination-language research that includes Reo (Arbab 2004) and Klaim (De Nicola, Ferrari & Pugliese 1998), and supplies one of the standard answers to “how do agents in a multi-agent system communicate without point-to-point addressing?”

Key Ideas

Tuple space as the universal medium: a logically shared, content-addressable bag of tuples; processes communicate exclusively through out / in / rd / eval on this single store.
Four operations:
- out(t) — write tuple t to the space (non-blocking).
- in(template) — atomically consume a tuple matching template (blocks until one exists).
- rd(template) — read but do not consume a matching tuple (blocks until one exists).
- eval(t) — like out, but each non-actual field is evaluated by a fresh concurrent process; producing a live, in-tuple-space computation.
Associative pattern matching: a template is a tuple containing actual values and typed wildcards; a tuple matches a template iff the structural shapes agree, the actual values are equal, and the wildcards bind to fields of the matching type.
Four dimensions of decoupling: Linda decouples sender and receiver in space (no shared address space), time (writer and reader need not co-exist), destination (no addressing — match by content), and form (any tuple format can be matched by an appropriate template).
Separation of computation and coordination: Linda is a coordination language deliberately orthogonal to the host computation language; a parallel program decomposes into a sequential computation plus a Linda coordination structure.
Generative communication: produced tuples have an existence independent of the producer — they live in the space, persist until consumed, and can be matched by any process. The producer-consumer decoupling this implies is what made tuple spaces attractive for systems with unpredictable producer/consumer matching.
Implementation tractable but not trivial: efficient Linda implementations distribute the tuple space (statically by tuple shape, dynamically by hashing), specialise frequent matching patterns, and treat in/rd as conditional rendezvous; significant systems-engineering work, but feasible.

Connections

Conceptual Contribution

Claim: Coordination of parallel and distributed processes can be elegantly expressed via a content-addressable shared tuple space accessed through four primitives (out, in, rd, eval); this decouples senders and receivers in space, time, destination, and form, and supports a clean separation of computation and coordination. Coordination is its own first-class concern, distinct from the computation it orchestrates.
Mechanism: Logically shared bag of tuples; associative pattern matching with typed wildcards; four primitive operations forming a small coordination language; embedded combination with any host computation language (C-Linda, Fortran-Linda, Java for JavaSpaces, etc.); distributed implementation via tuple-shape partitioning and matching specialisation.
Concepts introduced/used: Generative Communication, Linda (coordination), Tuple Matching, Tuple Spaces, Coordination Language, Separation of Computation and Coordination, Four Dimensions of Decoupling.
Stance: foundational systems-engineering paper.
Relates to: Direct ancestor of JavaSpaces (Sun, 1998), TSpaces (IBM, 1999), GigaSpaces (commercial), and the academic descendants KLAIM (De Nicola, Ferrari & Pugliese 1998 — Linda + mobile-agent locality), and (more loosely) Reo (Arbab 2004 — connector-based coordination as algebraic counterpoint to Linda’s tuple-space model). The conceptual move “coordination is a separate first-class concern from computation” is shared with Kowalski’s Algorithm = Logic + Control (1979) — algorithm = logic + control = computation + coordination — and with the entire blackboard-architecture line in AI. Within this vault Linda is the missing canonical reference under the existing Tuple Spaces concept stub. In the agent-communication setting, tuple spaces supply an alternative to KQML/FIPA-style facilitator mediation: where KQML’s Facilitators route messages by content, tuple spaces let agents publish content into a shared medium and let consumers match on what they want — the Agents and Artifacts (JaCaMo / CArtAgO) framework explicitly takes this stance, treating the shared environment as a first-class artefact agents communicate through. The pattern is also foundational for stigmergic coordination (the world is the shared medium) and for Ripple Effect Protocol-style sensitivity sharing among agents.

Summary

Shoham introduces Agent-Oriented Programming (AOP) as a specialization of object-oriented programming in which the state of each module — now called an agent — is a mental state composed of beliefs, capabilities, decisions/choices, commitments, and obligations. Interpretation of these components is formally grounded in an extension of standard epistemic logics that adds temporality, obligation, decision, and capability operators.

Agents communicate via speech-act-inspired primitives (inform, request, offer, promise, decline, etc.), constrained by rules such as honesty and consistency. The paper defines a class of agent interpreters and presents AGENT-0, a concrete implemented language whose semantics is tied to the mental-state logic. Shoham also discusses “agentification” — converting arbitrary devices into AOP-programmable agents — and situates AOP against BDI architectures, speech act theory, and McCarthy’s Elephant2000.

Key Ideas

AOP as OOP specialization with mental-state components.
Agents constrained by honesty/consistency on communicative acts.
Speech-act-typed primitives as message types.
AGENT-0 language and interpreter.
“Agentification” of arbitrary devices.

Connections

Conceptual Contribution

Claim: Programming can be fruitfully specialised to an “agent” paradigm in which module state is a formally specified mental state and inter-module communication is a speech act constrained by rational/ethical rules.
Mechanism: Shoham extends standard modal-epistemic logic with temporal, obligation, decision and capability operators, defines the mental-state components of an agent (belief, capability, commitment, choice, obligation), then specifies a generic agent interpreter cycle (update mental state, execute commitments, handle incoming messages) and instantiates it in AGENT-0, whose programs are condition-action rules over mental state and whose messages are typed INFORM/REQUEST/UNREQUEST primitives.
Concepts introduced/used: Agent-Oriented Programming, Mental State, Commitment, AGENT-0, Speech Act Theory, Agentification, BDI, Honesty Constraint
Stance: foundational
Relates to: Establishes the mentalistic ACL stance later criticised by Agent Communication Languages - Rethinking the Principles and surveyed by Intelligent Agents Theory and Practice; AGENT-0’s speech-act primitives anticipate KQML as an Agent Communication Language and FIPA-ACL; the mental-state architecture is reused in An Interaction-oriented Agent Framework for Open Environments.

Reference

Jennings, Nicholas R. (2000). “On agent-based software engineering.” Artificial Intelligence 117(2): 277–296. (Based on the Computers and Thought Award lecture, IJCAI-99 Stockholm.)
PDF: jmvidal.cse.sc.edu/library/abse.pdf
Also: faculty.sites.iastate.edu/tesfatsi/archive/tesfatsi/jennings.pdf
ePrints Soton: eprints.soton.ac.uk/253741/
Local: jennings2000_agent_based_se.pdf

Summary

Jennings argues that agent-oriented techniques are not a mere rebranding of object-orientation or distributed computing but a genuinely new software engineering paradigm, particularly well-suited to complex, distributed, real-world systems. Contemporary software engineering paradigms (OO, component-ware, design patterns, software architectures) fall short in two ways when building such systems: (i) interactions between computational entities are defined too rigidly at design time, and (ii) there are insufficient mechanisms for representing a system’s organisational structure. He advances two theses: the Adequacy Hypothesis — agent-oriented approaches significantly improve our ability to model, design, and build complex distributed software — and the Establishment Hypothesis — agent orientation will succeed as a mainstream SE paradigm.

The paper offers a careful definition: an agent is an encapsulated computer system situated in some environment and capable of flexible autonomous action to meet its design objectives. Agents are (i) identifiable problem-solvers with well-defined boundaries, (ii) situated, (iii) purposive, (iv) autonomous (controlling both state and behaviour — this is what distinguishes them from objects, which must obey any public method call), and (v) flexible (reactive and proactive). Crucially, real problems require multi-agent solutions; the essential concepts of agent-based computing are agents, high-level (knowledge-level) interactions, and explicit organisational relationships. The canonical diagram shows agents, interaction links, organisational groupings, and spheres of visibility and influence over a shared environment.

Interactions are conceptualised at the knowledge level (Newell): who should do what, when, on whose behalf — not at the syntactic level of method invocation. Agents decide at run time how to interact, including engaging in interactions unforeseen at design time. Organisational relationships (peer, team, manager/subordinate) shape behaviour and must be represented explicitly because they evolve during execution. Jennings then argues the case for agent-based software engineering, examines its drawbacks (hard to predict, hard to verify, concurrency pitfalls, immature methodologies), and advocates modelling at the social level as the promising remedy.

Key Ideas

Agents as the right abstraction for complex distributed systems: encapsulated, situated, autonomous, flexible.
Autonomy distinguishes agents from objects: objects must execute any invoked public method; agents choose whether to respond.
Interactions at the knowledge level: goal-level, run-time, negotiated — not hard-wired at design time.
Explicit organisational structure: teams, roles, authority relations must be first-class, and must be dynamic.
The canonical view: agents + high-level interactions + organisational relationships + shared environment.
Adequacy and Establishment Hypotheses: agent-orientation is both appropriate and likely to become mainstream.
Social level modelling: beyond the knowledge level, systems should be analysed in terms of roles, dependencies, and collective behaviour.
Drawbacks acknowledged: emergent behaviour, verification difficulty, lack of mature tooling, overhead for simple problems.

Connections

Multi-Agent Systems — this paper is one of the foundational manifestos for viewing SE through the MAS lens.
Intelligent Agents Theory and Practice — Wooldridge & Jennings’s companion treatment of the agent abstraction.
Agent-Oriented Programming — Shoham’s earlier proposal to shift from objects to agents; Jennings provides the SE-level case.
Multiagent Systems Sycara — complementary survey of MAS as a field.
Agent Architecture, Abstract Agent Interfaces — concrete architectural instantiations of Jennings’s abstraction.
A Scalable Communication Protocol for Networks of LLMs — modern echo of the “knowledge-level interaction, organisational structure” agenda.
ACL Design Principles, ACL Layering, A Common Ontology Of ACLs — the communication machinery that knowledge-level interaction presupposes.
Agent Communication And Institutional Reality — institutional/organisational framing extends Jennings’s call for explicit organisational relationships.
Contrast with Actor Model — actors encapsulate state but not autonomy of response.
Contrast with Intelligence Without Representation — Jennings is comfortable with knowledge-level abstractions Brooks is sceptical of.

Conceptual Contribution

Coordination Artifacts

(page does not exist)

Working Environment

(page does not exist)

CArtAgO

Common Artifacts for Agents Open framework — a Java infrastructure implementing the Agents & Artifacts meta-model in which agents perceive and act on first-class environmental artifacts governed by observable properties and operations.

In this vault

Agents and Artifacts

Agents and Artifacts (A&A)

Meta-model treating the agent environment as first-class artefacts agents interact with, implemented in JaCaMo / CArtAgO.

In this vault

Agent Communication Languages

A concept hub for agent communication languages (ACLs): languages whose speech acts let software agents exchange beliefs, goals, and commitments.

Canonical Languages

KQML — original knowledge-query language
FIPA-ACL — standardised successor

Surveys & Principles

The State of the Art in Agent Communication Languages
Trends in Agent Communication Language
ACL Rethinking Principles — Singh, mental vs. social semantics
Agent Communication Languages - Rethinking the Principles
A Common Ontology Of ACLs
Toward Automated Evolution of ACLs
Towards Automating the Evolution of Linguistic Competence

Semantics

Conversations & Protocols

Domain instances

Common Business Communication Language — McCarthy 1975/1982
CBCL - Safe Self-Extending Agent Communication — O’Connor 2026 (LangSec ’26): contemporary Lean-verified DCFL-bounded ACL realising McCarthy’s CBCL vision

AgentSpeak

Rao’s (1996) operational BDI agent programming language: an agent is a triple of belief base (Prolog facts), plan library (event-triggered procedures), and intention stack (plans-in-execution). The interpreter cycles through perceive → event-generate → plan-select → execute. Eight-rule SOS-style operational semantics fits on a page. Made practically dominant through Jason (Bordini-Hübner-Wooldridge 2007), the most-deployed BDI platform in academic MAS research.

In this vault

Agent Architecture

The internal computational organisation of an agent — deliberative (BDI), reactive (subsumption), layered, or hybrid — along with the control loop and data pipelines that realise it.

In this vault

Architectural lineage

graph TD
  MC["McCarthy (1979)<br/>Ascribing Mental Qualities to Machines"] --> IS["Dennett<br/>Intentional Stance<br/>True Believers"]
  HEW["Hewitt (1973)<br/>Universal Modular Actor Formalism"] --> ACTOR[Actor Model]
  ACTOR --> CONC[Concurrent agents]
  BRAT["Bratman (1987)<br/>Intention Plans Practical Reason"] --> BDI[[BDI]]
  RG["Rao & Georgeff<br/>BDI Logic"] --> BDI
  MIN["Minsky<br/>Society of Mind"] --> SOC[Societies of sub-agents]
  BRO["Brooks (1991)<br/>Intelligence Without Representation"] --> SUB[Subsumption]
  SUB --> REACT[Reactive / behaviour-based]
  IS --> SHO["Shoham (1993)<br/>AGENT-0 · Agent-Oriented Programming"]
  BDI --> SHO
  SHO --> AA((Agent Architecture))
  REACT --> AA
  SOC --> AA
  CONC --> AA
  AA --> HYB[Hybrid / layered]

Papers: A Universal Modular Actor Formalism for Artificial Intelligence · Ascribing Mental Qualities to Machines · Intelligence Without Representation · The Society of Mind · True Believers - The Intentional Strategy and Why It Works · AGENT-0

Agent Infrastructure

Technical systems and shared protocols external to individual AI agents that mediate their interactions with each other, humans, and institutions. Three core functions per Chan et al. 2025: attribution (agent IDs, credentials, audit), interaction shaping (protocols, mechanism design, reputation), and detection & remediation (anomaly detection, rollback, compensation).

In this vault

Multi-Agent Systems

Systems of multiple autonomous agents that interact, coordinate, and sometimes compete.

Foundations

Intelligent Agents Theory and Practice — Wooldridge
Multiagent Systems Sycara
Agent-Oriented Programming — Shoham

Coordination & robustness

An Interaction-oriented Agent Framework for Open Environments (Mercurio)

Reference: Baldoni, Baroglio, Bergenti, Marengo, Mascardi, Patti, Ricci, Santi (2011). AIIA 2011 (Italian AI Association)*. Source file: cbcl-ref/AI_IA2011.pdf. URL

Summary

The authors propose Mercurio, an agent-programming framework for open multi-agent systems that unifies direct (speech-act) and indirect (environment-mediated) communication under a single social/observational semantics based on commitments. Mercurio has three levels — specification (constitutive and regulative rules over a domain model), programming abstractions (Agents and Artifacts in the A&A meta-model), and infrastructure (built on JaCaMo integrating Jason, CArtAgO, and MOISE).

Commitment-based protocols give a public, verifiable meaning to actions (replacing mentalistic ACL semantics); constitutive rules define what counts as what, while regulative rules impose temporal constraints on the social state. Artifacts reify interaction patterns and the social state itself, enabling the environment to monitor and detect violations. The framework thus conjugates MAS flexibility with software-engineering modularity and compositionality, targeting e-government, cross-business, and service-oriented applications.

Key Ideas

Commitment-based social semantics replaces mentalistic ACL semantics.
Three levels: specification, programming abstractions, infrastructure.
Separation of constitutive and regulative rules.
Artifacts (A&A / CArtAgO) as first-class environment entities.
JaCaMo stack (Jason + CArtAgO + MOISE) as reference infrastructure.

Connections

Conceptual Contribution

Claim: Open multi-agent systems need a single, publicly verifiable interaction semantics that unifies direct (speech-act) and indirect (environment-mediated) communication; commitments plus Agents-and-Artifacts supply it and can be layered onto an existing AOP stack.
Mechanism: Mercurio stratifies into three levels. (1) Specification: a domain model plus constitutive rules (“what counts as what”) and regulative rules (temporal constraints on the social state). (2) Programming abstractions: the A&A meta-model (agents + artifacts) where artifacts reify interaction patterns and the social state itself. (3) Infrastructure: the JaCaMo stack (Jason + CArtAgO + MOISE) runs the above so violations are environment-detectable and the social state is inspectable.
Concepts introduced/used: Mercurio Framework, Commitment-Based Protocol, Constitutive Rules, Regulative Rules, Agents and Artifacts, JaCaMo, Jason, CArtAgO, MOISE, Social State
Stance: engineering
Relates to: Concretely instantiates the social-semantic programme of Agent Communication Languages - Rethinking the Principles and the open-issue agenda of Trends in Agent Communication Language and The State of the Art in Agent Communication Languages; its environment-reified interaction complements the self-organisation of A Composite Self-organisation Mechanism in an Agent Network.

“Give Agents their Artifacts”: The A&A Approach for Engineering Working Environments in MAS

Summary

Key Ideas

Connections

Conceptual Contribution

Tags

Backlinks