This chapter is the deck M11 — Agents & Tools, the last Module 1 lecture of the course. Its structure is striking: the first three sections ask a conceptual question — what are tools to agent intelligence and autonomy? — the middle sections answer it with the current state of Agentic AI (from LMMs to tool-using agents), and the last sections answer it with a long research tradition: the theory of artefacts, culminating in the A&A meta-model. The chapter connects backwards to Chapter 10 (tool use needs plans — hence planning and search for long-horizon tool use), and forwards to Chapter 12 (Jade implements FIPA’s agent platform — the very FIPA that, the deck complains, ignores pragmatic actions and focuses on communication only), and beyond (the artefacts of A&A are implemented by JaCaMo, which the Jason chapter will meet).
The deck opens with a provocation about how we evaluate intelligence. Humans see a strong relationship between language and intelligence: the ancient Greek word barbaros generically brands those who do not speak “proper language” as semi-humans; the Imitation Game in the classical “AI-detection” Turing test [Turing, 1950] just focuses on language; and the overwhelming tide of Generative AI is mostly built around large language models. As a result, the ability to articulate language is so frequently (ab)used as the main criterion to evaluate intelligence — when not the only one.
The alternative criterion is tools. The fundamental characterisation of Homo Abilis is its ability to forge tools [Antón, 2012]: H. Abilis could anticipate prospective use for (yet) non-existing objects, select materials and components to build them, and conceptually design and practically make them — such that we label the (Early) Stone Age based on its stone tool industry. Humans forge and use tools; our survival depends on the tools we design and build. A tool-equivalent of the Turing test has been proposed [Wood et al., 2005], and we often regard the ability of our fellow humans to use tools as an important element of distinction in the social realm. And, crucially for this course, the most recent wave of Agentic AI is largely predicated upon the use of tools.
The human ability to design and use tools is a fundamental sign of intelligence — e.g., Bergson’s notion of intelligence as the “faculty to create artificial objects, in particular tools to make tools, and to indefinitely variate its makings” [Bergson, 1907, Bergson, 1911].
If tools speak of intelligence, they also speak of autonomy. The deck’s reference is Hannah Arendt’s homo faber [Arendt, 1958]: the core anthropological figure to analyse human activity — specifically belonging to the sphere of work, as the fabrication of a durable, artificial world. Man the maker fabricates objects, builds an artificial, durable world, uses tools and instruments, and operates according to means–end rationality — where the world provides objectivity and shared reality, and is the condition for politics and memory.
The Italian Renaissance took the “Homo faber fortunae suae” locution to go beyond the idea of homo sapiens: knowledge is no longer merely contemplative, but aimed instead at changing the world — knowledge should be instrumental to action. Homo Faber is the actor and constructor of the world; according to Pico della Mirandola, humans are the only ones in the Great Chain of Beings (“la scala degli esseri”) able to forge themselves, exploiting their unique freedom of choice to “either ascend upward or descend into brutishness”. Where “action”, “choice”, “freedom” speak to us of autonomy — whereas “world” speaks to us of society and environment.
Notice the pair being assembled: tools are the instrument of intelligence (section 1) and the instrument of autonomy (here, through the freedom to act on the world). The rest of the chapter asks what this pair means for agents.
With the human picture in place, the deck turns to agents:
Is there the (conceptual, technical, practical) need for an Agens Faber? [Omicini et al., 2006]
This is the chapter’s research question, stated once at the beginning and answered in two registers: the Agentic AI register (sections 4–17, what the field does today) and the artefact register (sections 18–28, what a century of multi-disciplinary theory already knew).
The Agentic AI half starts with a minimal mathematical view of a plain LLM. At its core, a standard large language model implements conditional sequence modelling: it receives a fixed textual context, produces output one token at a time, and — crucially — it does not intrinsically maintain persistent goals, does not intrinsically act on the external world, and does not intrinsically execute a control loop. In the narrow formal sense, everything it does is somehow reducible to sequence continuation:
P(next token | previous tokens)Abstractly, a plain LLM call can be modelled as a function that repeatedly samples/selects from P(xt | x<t), where x<t is the previously generated prefix and xt the next token. There, state is implicit in the token context, computation is local to the current invocation, and output is textual.
Then the crucial distinction: a language model vs. an agent. In a plain language model, the core operation is (autoregressive) token prediction. An agentic system wraps that model inside a larger, stateful, goal-directed, action-taking process. What does “beyond” imply? AI agents include capabilities and execution semantics not captured by token prediction alone, such as:
This is Chapter 10’s vocabulary (plans, subgoals, replanning) reappearing inside an LLM-centred architecture — the deck is explicitly recycling the planning concepts of the previous lecture.
The deck now characterises agentic computation through five slides, each adding one property.
input → output; an agentic system operates instead as a closed-loop process: observe → decide → act → observe → …. Agentic computation depends on both previously emitted tokens and the outcomes of (external) actions executed.The deck condenses the previous section into a table worth memorising:
LLM: conditional token prediction. Agentic system: iterative decision process.
LLM: single pass. Agentic system: multi-step loop.
LLM: implicit in context. Agentic system: explicit, persistent.
LLM: text. Agentic system: text & actions.
LLM: prompt-implied. Agentic system: explicitly tracked.
LLM: none. Agentic system: active.
LLM: limited to current context. Agentic system: possibly revised based on feedback.
The canonical implementation pattern of an AI agent is a minimal loop:
LLM environment feedback
state_t → action_t → observation_t → state_{t+1}There, state persists across iterations, actions have semantics outside the text stream, and new observations are externally generated. This is the architecture-level counterpart of the BDI loop of Chapter 7 and the planning–execution alternation of Chapter 10: an LLM supplies the decision, the environment determines the outcome, and the state carries the history.
The deck surveys the main architectures currently used, each a specific filling of the canonical loop.
ReAct [Yao et al., 2022] interleaves reasoning with tool use, in the typical pattern reasoning → action → observation → reasoning → …. The role split: the model proposes a thought and an action; the runtime executes the action; the result is injected back as an observation. Model output is used to trigger real operations whose outcomes shape future computation. The minimal formalisation: at each step t, (at, rt) = LLM(ht), ot = Env(at), ht+1 = ht ∪ {at, ot}, where ht is the running history, at the action, rt the model’s reasoning output, and ot the observation from the environment after at execution.
In tool-using systems such as Toolformer [Schick et al., 2023], the model can emit structured calls instead of just free-form text — for example get_weather(city = "Bologna"). The runtime then validates arguments, dispatches the tool, collects the result, and returns it to the model for further reasoning — so the model looks like a sort of online planner over available operations. Even though the model emits tool calls as tokens, this goes beyond token generation because: the output is interpreted under a schema; external software executes the requested function; the result re-enters the loop as new evidence; and the final outcome depends on the interaction with the environment — the LLM serves as a decision component within a larger computational activity.
AutoGPT-like [Richards, 2023] agents add persistence around a long-running loop: high-level goals, a task queue, memory storage, tool access, progress evaluation, self-revision / replanning — the loop being plan → act → observe → store → evaluate → repeat. The critical additions: persistence across iterations, explicit management of subgoals, modification of future behaviour based on accumulated history, and operational autonomy within a bounded task domain.
Planner-executor architectures separate high-level planning from low-level execution: a planner derives a multi-step strategy; an executor carries out each step; a controller monitors outcomes and triggers replanning if needed. Intelligence belongs to more than one single generation pass. A possible view: plan = LLM_planner(goal); oi = executor(stepi); revise plan if oi ≠ expected result. There, cognition is distributed across planning, acting, monitoring, and revision — Chapter 10’s plan–execution–replanning loop, implemented with an LLM planner.
In a typical Agentic AI setting, a multi-agent system contains a number of specialised agents or roles — e.g., researcher, planner, critic, executor — and a typical simple interaction pattern would be agent A proposes → agent B critiques → agent A revises → …. There, the overall computation emerges from inter-agent communication rather than from a single one-shot generation — the MAS perspective of the whole course, applied to LLM-based agents.
Memory-augmented systems add memory outside the immediate context window, using scratchpads, logs, vector stores, knowledge bases, and task-history repositories as memory forms. A typical loop: query → retrieve memory → generate → update memory. Formally: mt = retrieve(qt, M); yt = LLM(xt, mt); M ← M ∪ store(yt). Knowledge has continuity — no need to encode it just in the context.
Despite their diversity, all the aforementioned architectures share the same ingredients: iterative control, explicit state, action semantics, environmental feedback, and adaptation over time. A compact abstract representation:
s_{t+1} = f( s_t , LLM(s_t) , Env )where st is the current state, LLM(st) supplies a decision, proposal, or action, Env determines the result of environment interaction, and f updates the state for the next iteration. This captures the essential move: from stateless prediction to stateful control.
An agent goes beyond next-token generation by deciding when to invoke external capabilities — and which ones, specifically: search, APIs, code execution, databases, browsers, simulators, … The minimal loop is reason → select tool → call tool → get feedback → repeat.
Generally speaking, the notion of tool use addresses three recurring limits of standalone LLMs:
Tool-augmented agents are usually framed as LLM core + memory + planner + tool interface [Qu et al., 2025] — note the deck’s formula explicitly contains a planner, reconnecting to Chapter 10.
The deck gives the canonical loop an agent follows when using tools:
The key design tension: how much of this loop is learned end-to-end, and how much is instead specified by prompting, symbolic control, or orchestration code? This tension structures the taxonomy of the next section and the prompted-vs-learned debate of section 13.
The deck organises the landscape of tool-using models into seven paradigms, each with its main idea and examples:
Prompted / structured calls: the model emits explicit tool invocations, often JSON or function calls. Examples: Zero-shot planners, ReAct. Main idea: tool use as an inference-time prompting problem.
Self-supervised tool learning: the model is trained to insert API calls into text corpora. Example: Toolformer. Main idea: tool-use policies learned during model training.
Program-as-action: the model writes code and delegates execution to an interpreter. Example: PAL. Main idea: executable code as universal tool interface.
Search / deliberate planning: the model explores multiple reasoning branches or explicit plans. Examples: Tree of Thoughts, Plan-and-Solve, Least-to-Most. Main idea: tool use as (long-horizon) search.
Retrieval-augmented agents: retrieval is treated as a first-class tool for grounding knowledge. Examples: REALM, RAG. Main idea: “look things up” as an explicit external memory mechanism.
Memory-rich / embodied agents: long-term memory, reflection, and environment interaction are explicit modules. Examples: Generative Agents, Voyager. Main idea: “remember and reflect”, “learn how to do things and reuse them in the world”.
Benchmark-driven tool tuning: training and evaluation focus on realistic API use and multi-tool workflows. Examples: API-Bank, ToolLLM / ToolBench. Main idea: realistic tool ecosystems as the training ground.
Two families of approaches stand out, and the deck contrasts them directly.
reasoning → action → observation → reasoning → …. Benefits: cheap to prototype, interpretable. Weaknesses: tool selection depends heavily on prompt quality; brittle formatting and argument generation; long-horizon failures accumulate across turns.Takeaway — a central divide in the literature is about what tool use primarily is: either an inference-time prompting problem or a learned policy problem.
Real tool use is seldom one-shot: agents often need multi-step decomposition, recovery from failed calls, backtracking when retrieved evidence contradicts earlier assumptions, and budget-aware search over action sequences. Hence the planning-and-search family of techniques:
This is Chapter 10’s thesis in LLM clothing: long-horizon problems need plans, and plans turn tool use into a search problem — with decomposition, backtracking and budget as first-class concerns.
REALM [Guu et al., 2020] and RAG [Lewis et al., 2020] establish retrieval as an explicit external memory mechanism rather than implicit parametric knowledge only — “look things up”. Generative Agents [Park et al., 2023] emphasise memory streams, reflection, and planning as explicit architectural modules for believable long-term behaviour — “remember and reflect”. Voyager [Wang et al., 2023a] explores open-ended embodied interaction, using iterative prompting, skill libraries, and environment feedback — “learn how to do things and reuse them in the world”.
A wide notion of tool: in Agentic AI systems, retrieval, episodic memory, and executable skills are usually all treated as tools — just tools with different latency, semantics, and reliability profiles.
The deck presents the two flagship benchmarks: API-Bank [Li et al., 2023], probing planning, retrieval, and API calling in runnable tool-use dialogues — an early systematic benchmark for tool-augmented LLMs; and ToolLLM / ToolBench [Qin et al., 2024], moving toward realistic tool ecosystems with large-scale real-world APIs, multi-tool instruction following, and automatic evaluation pipelines.
The common evaluation axes [Li et al., 2023, Qin et al., 2024]:
The Agentic AI half closes with six open problems, worth listing in full because they structure the current research agenda:
The deck’s suggested reading roadmap runs in six steps: inference-time paradigms [Huang et al., 2022, Yao et al., 2022]; learned tool-use and programmatic execution [Schick et al., 2023, Gao et al., 2023]; planning/search [Zhou et al., 2023, Wang et al., 2023b, Yao et al., 2023]; grounding and memory [Guu et al., 2020, Lewis et al., 2020, Park et al., 2023]; benchmarks and open platforms [Li et al., 2023, Qin et al., 2024]; survey papers for synthesis [Qu et al., 2025, Wang et al., 2024]. Bottom line: the field is rapidly moving — from “LLM as text generator” to “LLM as orchestrator of external computation and action”.
The second half of the deck makes a disciplinary turn. We have basically answered none of the fundamental questions: what are tools to agent intelligence? what are tools to agent autonomy? is there any general theory for agents using tools? Yet (theories of) tools pre-exist Agentic AI: humans use tools — animals, too — and theories of tools are available outside the AI field: in psychology, organisational sciences, cognitive sciences, ethology, … The deck then distinguishes three degrees of cross-disciplinary research:
Keep the trans-disciplinary ideal in mind: the A&A meta-model of section 24 is exactly that — theories from the human sciences, generalised to software agents, returned to the MAS field.
(Cultural-historical) Activity Theory (AT) was born in the context of Soviet psychology, rooted in the dialectic materialism by Marx & Engels, mostly through the work of Lev Vygotsky (1926–62) [Vygotskiı̆, 1978]. Broadly speaking, AT is a very general framework for modelling human activities — how people learn, how society evolves — based on the concept of human activity as the fundamental unit of analysis. It was re-discovered in Computer Science in the last years [Nardi, 1996], mostly in fields like CSCW and HCI, then brought to the MAS field [Ricci et al., 2003].
AT focuses on human activities as social activities, understood within a social/organisational context, as separated by their respective (physical and ideal) objects. Cooperation is understood as a collaborative activity: it has one objective, it is distributed onto several actors who participate, and explicit norms and rules regulate the relationships among individual participants’ work.
AT identifies a three-layered structure for social (collaborative) activities [Bardram, 1998, Engeström et al., 1997]:
Adopting AT as a conceptual framework for MAS social activities has led to recognise that agents are not the only basic abstractions to model and build MAS [Ricci et al., 2003]: artefacts, too, are necessary [Ricci et al., 2006] — to enable and constrain agent actions, to mediate agent interactions with other agents and with the environment, to model and shape the MAS environment, and in general to improve agent ability to achieve individual and social goals.
The three AT levels re-interpreted for MAS collaboration:
Distributed cognition is a branch of cognitive sciences [Kirsh, 1999] which proposes that human cognition and knowledge representation — rather than being solely confined within individuals — is distributed across individuals, tools, and artefacts in the environment.
For MAS: cognition and knowledge representation do not belong to agents only — objects and tools in the environment may participate in cognitive processes, and the structure of the MAS environment may explicitly represent knowledge. Cognitive artefacts encapsulate knowledge as explicitly represented. The MAS environment is structured by (cognitive) artefacts, and its structure changes the nature of agent action, affects agent mutual interaction, and modifies the way agents coordinate in a MAS — it should be designed to help agent actions achieve their goals and to make epistemic, complementary, coordinative agent actions easier and more effective.
The sociological perspective [Conte and Castelfranchi, 1995] contributes the conceptual pair agents with goals vs. artefacts with functions.
The deck closes the sociological block with the design questions this raises for MAS engineers: should an agent be aware of artefact behaviour and structure, and of how to use them? should an agent be able to reason and deliberate about artefact use? should an agent be aware of the artefact function and its potential uses? should an agent be able to act over artefacts to modify them and adapt their function, or to create ad hoc artefacts ex novo? should a MAS engineer be able to do the same at run-time? And symmetrically, how should an artefact be made in order to be ready for agent use (aware or unaware, possibly in an open system), for evaluation and selection, for modification and adaptation, and how should the MAS environment be structured to allow artefact run-time creation and modification?
Computer Supported Cooperative Work (CSCW) aims at automating human cooperative work through computational procedures. However, two diverging strategies were observed [Schmidt and Simone, 2000]:
Main problem: the two strategies diverge, but they should instead converge. The key issues:
Translated to MAS: coordinative artefacts rule MAS collaboration, working more as constrainers rather than as commanders; they structure the MAS common field of work as specialised abstractions automatising and making collaboration efficient, while promoting flexibility of intelligent agent coordination and respecting agent autonomy. The shared MAS environment should be structured as the MAS common field of work, so agents can mutually perceive each other’s activities (mutual awareness) — promoting opportunistic alignment and improvisation, and ensuring flexibility to MAS collaboration.
The last foundational block attacks the logocentric philosophical bias directly. Western anthropology has long dwelt on the human capacity of language as the main sign of intelligence, while the relation between language, use of tools, and evolution of intelligence has long been neglected [Hewes, 1993]. Yet the human capacity of designing, developing, and using tools is a fundamental sign of intelligence — the first characterisation of Homo Abilis is its ability to forge tools (the tool using vs. tool making distinction), and evidence of co-evolution of language and tool use along with human intelligence is overwhelming in modern anthropological studies [Gibson and Ingold, 1993].
From ethology: use of tools is not an exclusive feature of humans — beavers build dams, bees construct perfect hexagonal cells, many birds live in self-made nests, even cows scratch their backs with sticks. Ethologists commonly measure the intelligence of animals by making them face problems that require the use of tools to be solved [Povinelli, 2000]; a sort of tool-equivalent of the Turing test has been proposed by philosopher Ronald Endicott — the so-called “Tooling Test for Intelligence” [Wood et al., 2005]. And from anthropology: use of tools reveals awareness of self [Martelet, 1998] — when using a tool, a creature shows it is able to distinguish and identify itself from the world around; whenever a tool is built with a goal, stored for further/repeated use, used for building new tools, etc. Along with language, tools are at the same time the first and the most distinctive expression of human intelligence, and the most powerful amplifiers of the (both individual and social) human ability to affect the environment — to survive environment change first, to change the environment for human purposes then.
The bias in MAS: research on MAS still dwells on the logocentric bias — LLMs in Agentic AI push in the very same direction — and the intelligent use of tools by agents is typically neglected in “classical MAS literature”. As a stunning example, FIPA just ignores pragmatic/physical agent actions, and only focuses on agent communication actions. The deck’s corrective agenda: a notion of tool for agents is needed; agents should be able to use tools; intelligent agents should be able to forge and adapt tools; a theory of physical/pragmatical action should be developed for agents, as refined as the one for communication actions, focused on tool use/creation by agents — the notion of Agens Faber goes along this very direction [Omicini et al., 2006]. Finally, a sort of “Tooling Test for Agent Intelligence” should be defined, aimed at evaluating agent intelligence in terms of their ability to exploit tools: agent intelligence should be measured by both the ability to communicate and the ability to use tools — the two abilities should be strictly related and “co-evolve”, and a common theory of agent action could be of use here.
Based on the conceptual foundations of the previous sections, the A&A meta-model is a conceptual framework for MAS modelling and engineering characterised in terms of three basic abstractions [Omicini et al., 2008]:
The agent definition is a reminder of Chapter 4: an A&A agent is an autonomous computational entity — genus: computational entities; differentia: autonomous, in that they encapsulate control along with a criterion to govern it. From autonomy, many other features stem: autonomous agents are interactive, social, proactive, and situated; they might have goals or tasks, or be reactive, intelligent, mobile; they live within MAS, and interact with other agents through communication actions, and with the environment with pragmatical actions.
The artefact definition mirrors the agent one: an A&A artefact is a computational entity aimed at the use by A&A agents — genus: computational entities; differentia: aimed to be used by agents. From use, many other features stem (essential or desirable, but need not be definitory):
Artefacts are the instruments for engineering the MAS environment. They mediate between agents and the environment — artefacts embody the portion of the environment that can be designed and controlled to support MAS activities; as an observable and controllable part of the environment, they can be monitored along with the development of MAS activities, to evaluate overall MAS performance, keep track of MAS history, and influence MAS behaviour and evolution. They are the essential tools for modelling the MAS environment and for shaping it so as to make it favourable to the development of MAS social activities.
As mediating tools, artefacts have both an enabling and a constraining function: enablers expand the agent’s ability to manipulate and transform different objects; constrainers make the environment perceived and manipulated through the artefact, not “as such”, within the limitations set by the artefact itself. The deck’s example: an agent-oriented printer driver — enabler, it enables agents to use a printer along with a number of its options; constrainer, it limits in general agent interaction with the printer to some well-defined interaction patterns.
The deck then lists the desirable features of A&A artefacts [Omicini et al., 2006], which would in principle enhance MAS engineers’/agents’ ability to use them for their own purposes:
The state, content, operations, interface and function of an artefact may be all or partially available to agents. Whereas in closed MAS this information could be hard-coded in the agent, in open MAS third-party agents should dynamically join a society and get aware at run-time of the necessary information about the available artefacts. Artefacts are often in charge of critical MAS behaviour [Omicini et al., 2004a]: inspecting them is fundamental to understand and govern the dynamics of a MAS.
An obvious extension of inspectability: the operational behaviour of an artefact should be not merely inspectable, but also controllable, so as to allow MAS engineers (or even intelligent agents) to monitor its proper functioning — stop and restart its working cycle, trace its inner activity, observe and control step-by-step execution.
Also related to inspectability, malleability (also called forgeability) is a key feature in dynamic MAS scenarios, when the behaviour of artefacts could require to be modified dynamically to adapt to the changing needs or mutable external conditions of a MAS — a crucial aspect in on-line engineering for MAS, and a perspective key issue for self-organising MAS.
Unlike agents — which as autonomous entities have the freedom of behaving erratically, e.g. neglecting messages — artefact operations, interface and function description can be used as the stable basis for a contract between an artefact and an agent.
Predictability can be easily related to formalisability: due to the precise characterisation that can be given to an artefact behaviour — until reaching e.g. a full operational semantics model, as developed for coordination artefacts [Omicini et al., 2004b] — it might be feasible to automatically verify the properties and behaviour of the services provided by artefacts, intrinsically easier than services provided by autonomous agents.
Artefacts can encapsulate and model reusable services in a MAS; to scale up with environment complexity, it may be interesting to compose artefacts — building a service incrementally on top of another, by making a new artefact realise its service by interacting with an existing artefact. To this end, artefacts should be able to invoke the operation of another artefact, the reply transmitted through the invocation of another operation upon the caller.
Unlike an agent — typically seen as a point-like abstraction conceptually located at a single network node — artefacts can also be distributed: a single artefact can model a distributed service accessible from more nodes of the net. Using linkability, a distributed artefact can be conceived and implemented as a composition of linked, possibly non-distributed artefacts — or vice versa. Altogether, distribution and linkability promote the layering of artefact engineering [Molesini et al., 2006].
The last artefact refinement targets intelligent agents. An A&A cognitional artefact is an artefact aimed at the cognitive use by agents — genus: artefacts; differentia: aimed to be used in a cognitive way by agents. In order to allow its rational exploitation by intelligent agents, an A&A artefact possibly exposes three things:
The deck’s example: a sensor wrapper. When modelling it as an artefact, the operations for sensor activation and inspection are described via usage interface and operating instructions, while the information about the sensory function itself is conveyed through the function description of the sensor wrapper.
The meta-model closes with the system-level definition: an A&A MAS is a computational system made of agents and artefacts — genus: computational system; differentia: its basic components are agents and artefacts. Two consequences:
Two fundamental entities give rise to four sorts of admissible interactions within a MAS:
Interactions also occur with the environment, within and without the boundaries that defining a system draws; depending on the desired level of abstraction, we may attribute environment interactions to individual agents and artefacts, or to the MAS as a whole.
What we already have: working technologies and patterns for AI agents using tools; a coherent model for rational agents using artefacts — the A&A meta-model; technologies for both — JaCaMo artefacts for rational agents, along with a fast-growing list of technologies for AI agents. What we are still missing: a coherent, all-encompassing model for any sort of agent using tools/artefacts — could we just call artefacts the tools, and merrily extend the A&A meta-model to cover everything? — and a general-purpose, full-fledged methodology to design intelligent systems exploiting the whole potential of the agent–tool relationship — could we just take good old AOSE methodologies and cheerfully extend them to cover the full range of Agentic AI systems engineering, including tool use? And, the deck’s final word: … what else? projects!
Language — the logocentric criterion: from the Greek barbaros, to the Imitation Game of the Turing test [Turing, 1950], to the overwhelming tide of Generative AI built around LLMs. And tools — the tool criterion: the fundamental characterisation of Homo Abilis is its ability to forge tools [Antón, 2012]; a tool-equivalent of the Turing test has been proposed [Wood et al., 2005]; the most recent wave of Agentic AI is largely predicated upon the use of tools. Bergson’s notion: intelligence as the “faculty to create artificial objects, in particular tools to make tools, and to indefinitely variate its makings”.
Homo faber [Arendt, 1958] is the core anthropological figure for analysing human activity, specifically belonging to the sphere of work as the fabrication of a durable, artificial world: man the maker fabricates objects, builds an artificial durable world, uses tools and instruments, and operates according to means–end rationality. The Italian Renaissance’s “Homo faber fortunae suae” goes beyond homo sapiens: knowledge aimed at changing the world; per Pico della Mirandola, humans are the only beings in the Great Chain able to forge themselves, exploiting their freedom of choice. “Action”, “choice”, “freedom” speak of autonomy; “world” speaks of society and environment.
Whether there is the (conceptual, technical, practical) need for an Agens Faber [Omicini et al., 2006]: a theory for agents using tools — what are tools to agent intelligence and to agent autonomy; is there a general theory for agents using tools, imagining tools, designing tools, forging tools, (socially) sharing tools?
A standard LLM implements conditional sequence modelling: it receives a fixed textual context and produces output one token at a time (P(next token | previous tokens)); it does not intrinsically maintain persistent goals, act on the external world, or execute a control loop. In the narrow formal sense, everything it does is reducible to sequence continuation: state is implicit in the token context, computation is local to the current invocation, output is textual. An agentic system wraps the model inside a larger, stateful, goal-directed, action-taking process.
Capabilities and execution semantics not captured by token prediction alone: running an iterative control loop, maintaining explicit state, taking external actions, receiving feedback from the environment, tracking goals and subgoals, possibly planning, revising, replanning.
Closed-loop vs. single-pass computation (observe → decide → act → observe → …); agentic systems are stateful (goal, plan, intermediate results, memory, tool outputs, error status); action semantics (from text as output to text as control signal: output interpreted as a tool call); environment feedback loop (observations folded back into the next decision step); planning and deliberation (task decomposition, ordering, progress checking, replanning, epistemic actions). Overall: core operation conditional token prediction vs. iterative decision process; execution single pass vs. multi-step loop; state implicit in context vs. explicit and persistent; output text vs. text and actions; goal handling prompt-implied vs. explicitly tracked; environment none vs. active; adaptation limited vs. revised based on feedback.
state_t → (LLM) action_t → (environment) observation_t → state_{t+1}: state persists across iterations, actions have semantics outside the text stream, new observations are externally generated.
ReAct [Yao et al., 2022] interleaves reasoning with tool use: reasoning → action → observation → reasoning → …. The model proposes a thought and an action; the runtime executes the action; the result is injected back as an observation. Formally, at each step t: (a_t, r_t) = LLM(h_t), o_t = Env(a_t), h_{t+1} = h_t ∪ {a_t, o_t}, where h_t is the running history, a_t the action, r_t the reasoning output, o_t the observation.
In Toolformer [Schick et al., 2023] the model emits structured calls (e.g., get_weather(city = "Bologna")); the runtime validates arguments, dispatches the tool, collects the result, and returns it to the model for further reasoning — the model looks like an online planner over available operations. This goes beyond token generation because the output is interpreted under a schema, external software executes the requested function, the result re-enters the loop as new evidence, and the final outcome depends on interaction with the environment: the LLM serves as a decision component within a larger computational activity.
AutoGPT-like [Richards, 2023] agents add persistence around a long-running loop (plan → act → observe → store → evaluate → repeat) with high-level goals, a task queue, memory, tool access, progress evaluation and self-revision. Planner-executor architectures separate a planner (multi-step strategy) from an executor (each step) and a controller (monitoring and replanning). Multi-agent systems in Agentic AI use specialised roles (researcher, planner, critic, executor) with propose–critique–revise patterns, computation emerging from inter-agent communication. Memory-augmented agents add memory outside the context window: m_t = retrieve(q_t, M); y_t = LLM(x_t, m_t); M ← M ∪ store(y_t).
Iterative control, explicit state, action semantics, environmental feedback, and adaptation over time. Abstractly: s_{t+1} = f(s_t, LLM(s_t), Env) — the move from stateless prediction to stateful control.
Stale or missing world knowledge; weak symbolic reliability; inability to act on the external environment. Tool-augmented agents are usually framed as LLM core + memory + planner + tool interface [Qu et al., 2025].
Perceive state → plan → select tool → call (with arguments, via constrained schemas) → verify & integrate → act or respond. Key design tension: how much of this loop is learned end-to-end, and how much is specified by prompting, symbolic control, or orchestration code?
Prompted / structured calls (Zero-shot planners, ReAct); self-supervised tool learning (Toolformer); program-as-action (PAL); search / deliberate planning (Tree of Thoughts, Plan-and-Solve, Least-to-Most); retrieval-augmented agents (REALM, RAG); memory-rich / embodied agents (Generative Agents, Voyager); benchmark-driven tool tuning (API-Bank, ToolLLM / ToolBench).
Whether tool use is primarily an inference-time prompting problem (zero-shot planners, ReAct: cheap, interpretable, but prompt-dependent and brittle) or a learned policy problem (Toolformer: self-supervised insertion of API calls into text corpora; PAL: programs executed by an interpreter as universal tool interface).
Real tool use is seldom one-shot: agents need multi-step decomposition, recovery from failed calls, backtracking when evidence contradicts earlier assumptions, and budget-aware search over action sequences. Techniques: Least-to-Most prompting (ordered subproblems), Plan-and-Solve (planning separated from execution), Tree of Thoughts (multiple candidate reasoning branches).
Selection accuracy (right tool?), argument correctness (valid/complete parameters?), trajectory quality (useful/efficient intermediate calls?), final task success (whole workflow solved the problem?), robustness (recovery from tool errors, malformed outputs, missing evidence?). Benchmarks: API-Bank [Li et al., 2023], ToolLLM / ToolBench [Qin et al., 2024].
When should an agent use a tool (overuse → latency/cost, underuse → hallucination)? How should tool outputs be trusted (wrong, adversarial, stale)? How do we verify trajectories (final correctness hides intermediate failures)? How do we manage long-horizon memory? How do we make tool use safe (irreversible external effects)? How should we train (imitation, synthetic data, RL-style optimisation, hybrid symbolic control)?
We have basically answered none of the fundamental questions (tools to intelligence, tools to autonomy, general theory of agents using tools), even though theories of tools pre-exist Agentic AI in psychology, organisational sciences, cognitive sciences, ethology. Multi-disciplinary: multiple areas involved, results from/drawn to different fields. Inter-disciplinary: models/methods/techniques brought from one area to a different one, results mainly concerning the latter. Trans-disciplinary: brought to a new area, extended and generalised, then results brought back to the original area.
AT is a very general framework for modelling human activities as social activities, born in Soviet psychology (Vygotsky [Vygotskiı̆, 1978]), rediscovered in CSCW/HCI [Nardi, 1996], brought to MAS [Ricci et al., 2003]. Every activity is mediated by mediating artefacts (physical or psychological). Artefacts are the tools that mediate actions and social interactions; they embody the designed, controllable portion of the environment; they are both a means and a product of social activity; they have both an enabling and a constraining function (e.g., a driving wheel). Three layers: co-ordination (scripted roles, exploiting artefacts), co-operation (shared objective, building artefacts as means of work), co-construction (re-conceptualising the objective). In MAS: agents are not the only abstractions needed — artefacts are necessary to enable/constrain actions, mediate interactions, and shape the environment.
Distributed cognition [Kirsh, 1999] proposes that human cognition and knowledge representation, rather than being confined within individuals, is distributed across individuals, tools and artefacts in the environment. Cognitive artefacts [Norman, 1992] are artificial devices that maintain, display, or operate upon information to serve a representational function and affect human cognitive performance (post-its, calendars, computers); they are not mere amplifiers — they modify the nature of the tasks performed. System view: individuals plus artefacts altogether as functional subsystems; personal view: individuals as subsystems affected by artefacts. For MAS: cognition is distributed in the environment; cognitive artefacts encapsulate knowledge; the structured environment changes agent action, interaction and coordination.
Agents are goal-driven: goal-governed (strong agency, explicitly represented goals driving action selection) or goal-oriented (weak agency, goals implicitly encoded); goals are internal. External goals belong to the social context and condition agent behaviour; a goal-governed system follows external goals by adjusting internal ones. Artefacts have a function, no goals; they may have a destination — an external goal attached by an agent in the act of using it. Destination is related but not identical to function: an artefact can be used according to a destination that differs from its designed function. Use value (drives selection) vs. use (guides actual usage). Ways of dealing with artefacts: use, selection, construction & manipulation.
Automation — stressing computational procedures to automate coordination (coordination by computational entities ruling collaboration) — vs. flexibility — stressing flexibility of computational procedures for intelligent coordination by collaborating actors. They should converge. Mutual awareness (through the common field of work) ensures flexibility; coordinative artefacts (the rulers of collaboration) work as constrainers rather than commanders: they define and govern the space of admissible articulation of activities without imposing pre-defined courses of action.
Western anthropology has long treated language as the main sign of intelligence while neglecting tools [Hewes, 1993]; modern studies show overwhelming evidence of co-evolution of language and tool use [Gibson and Ingold, 1993]. Ethology measures animal intelligence via tool-using problems [Povinelli, 2000]; the “Tooling Test for Intelligence” [Wood et al., 2005] is a tool-equivalent of the Turing test; tool use reveals awareness of self [Martelet, 1998]. In MAS the bias persists: LLMs in Agentic AI push in the same direction, and FIPA just ignores pragmatic/physical agent actions, focusing only on communication actions. The agenda: a notion of tool for agents, agents able to forge and adapt tools, a theory of pragmatic action as refined as communication, the Agens Faber notion [Omicini et al., 2006], and a “Tooling Test for Agent Intelligence”.
Agents: proactive components encapsulating the autonomous execution of activities inside an environment. Artefacts: passive components (resources and media) intentionally constructed, shared, manipulated and used by agents to support their activities, cooperatively or competitively. Workspaces: conceptual containers of agents and artefacts, defining the topology of the environment and a notion of locality [Omicini et al., 2008].
Artefacts have a function (designed for use); are transparent and predictable; are not autonomous (designed to serve, “governed” by agents); are computationally reactive (behave in response to agent use); have operations and interfaces; are situated (function expressed in terms of change to the environment) and reactive to change; and are not agents (agents are autonomous, opaque, may have goals, use artefacts, speak with agents; artefacts are predictable, have functions, are used, and cannot be used by agents).
Inspectability (state/content/operations/interface/function available to agents, crucial in open MAS); controllability (monitor, stop/restart, trace, step-by-step execution); malleability/forgeability (change behaviour at execution time); predictability (stable basis for an agent–artefact contract); formalisability (precise characterisation until operational semantics, enabling automatic verification); linkability (compose artefacts, invoke operations of other artefacts); distribution (artefacts can be distributed, unlike point-like agents) [Omicini et al., 2006].
A cognitional artefact is an artefact aimed at cognitive use by agents. It possibly exposes: a usage interface (the set of operations, like interfaces of services/components/objects); operating instructions (a description of the procedure to interact meaningfully over time — usage protocols, like a manual for a human); and a function description (what to obtain from the artefact, used for selection — unlike operating instructions, which describe how to exploit it). Example: a sensor wrapper, with activation/inspection operations in interface and instructions, and the sensory function in the function description.
An A&A MAS is a computational system whose basic components are agents and artefacts. It is situated (immersed within an environment, both entities situated) and has a behaviour (from the interaction of autonomous agents with goals and reactive artefacts with functions). Four interactions: communication (agents speak with agents), operation (agents use artefacts), composition (artefacts link with artefacts), presentation (artefacts manifest to agents).
We have: working technologies and patterns for AI agents using tools; a coherent model for rational agents using artefacts (the A&A meta-model); technologies for both — JaCaMo artefacts for rational agents, plus a fast-growing list of technologies for AI agents. We miss: a coherent, all-encompassing model for any sort of agent using tools/artefacts (could we call artefacts the tools and extend A&A?); a general-purpose, full-fledged methodology for intelligent systems exploiting the agent–tool relationship (could we extend AOSE methodologies to Agentic AI systems engineering, including tool use?); and — projects!