Distributed Agent-Based Computing in
Material-Embedded Sensor Network Systems
With the Agent-on-Chip Architecture
Stefan Bosse
AbstractDistributed material-embedded systems like sensor
networks integrated in sensorial materials require new data
processing and communication architectures. Reliability and
robustness of the entire heterogeneous environment in the pres-
ence of node, sensor, link, data processing, and communication
failures must be offered, especially concerning limited service of
material-embedded systems after manufacturing. In this paper,
multiagent systems with state-based mobile agents are used for
computing in unreliable mesh-like networks of nodes, usually
consisting of a single microchip, introducing a novel design
approach for reliable distributed and parallel data processing
on embedded systems with static resources. An advanced high-
level synthesis approach is used to map the agent behavior to
multiagent systems implementable entirely on microchip-level
supporting agent-on-chip (AoC) processing architectures. The
agent behavior, interaction, and mobility are fully integrated
on the microchip using a reconfigurable pipelined communicat-
ing process architecture implemented with nite-state machines
and register-transfer logic. The agent processing architecture is
related to Petri Net token processing. A reconfiguration mech-
anism of the agent processing system achieves some degree of
agent adaptation and algorithmic selection. The agent behavior,
interaction, and mobility features are modeled and specified with
an activity-based agent behavior programming language. Agent
interaction and communication is provided by a simple tuple-
space database implemented on node level and signals providing
remote inter-node level communication and interaction.
Index Terms Mobile agents, intelligent agents, parallel
processing, distributed information systems.
MBEDDED systems required for sensorial perception
and structural monitoring (perceptive networks), used,
for example in Cyber-Physical-Systems (CPS) and Structural
Health Monitoring (SHM) [6], perform the monitoring and
control of complex physical processes using applications
running on dedicated execution platforms in a resource-
constrained manner and with real-time processing constraints.
Trends emerging recently in engineering and micro-system
applications such as the development of sensorial materials
[15] show a growing demand for autonomous networks of
Manuscript received September 2, 2013; revised December 31, 2013;
accepted January 6, 2014. Date of publication January 22, 2014; date of
current version May 22, 2014. The associate editor coordinating the review
of this paper and approving it for publication was Dr. Dirk Lehmhus.
The author is with the Department of Computer Science, Working Group
Robotics, ISIS Sensorial Materials Scientific Centre, University of Bremen,
Bremen 28359, Germany (e-mail:
Color versions of one or more of the figures in this paper are available
online at
Digital Object Identifier 10.1109/JSEN.2014.2301938
miniaturized smart sensors and actuators embedded in tech-
nical structures [6] (see Fig. 1). To reduce the impact of
such embedded sensorial systems on mechanical structure
properties, single microchip sensor nodes (in mm
range) are
preferred. Real-time constraints require parallel data process-
ing usually not provided by microcontrollers. Hence with
increasing miniaturization and node density, new decentralized
network and data processing architectures are required. Multi-
agent systems (MAS) can be used for a decentralized and
self-organizing approach of data processing in a distributed
system like a sensor network [2], enabling the mapping
of distributed raw sensor data to condensed information,
for example based on pattern recognition [5]. In [2], the
agent-based architecture considers sensors as devices used
by an upper layer of controller agents. Agents are organized
according to roles related to the different aspects to integrate,
mainly sensor management, communication and data process-
ing. This organization isolates largely and decouples the data
management from the changing network, while encouraging
reuse of solutions. Multi-agent system-based structural health
monitoring technologies are used to deal with high-density
and different kinds of sensors in reliable monitoring of large
scale engineering structures [5]. In [18] and [19], agents are
deployed for distributed sensing and power management in
wireless sensor networks, but still using embedded system
nodes not suitable for material integration.
Material-embedded data processing systems usually consist
of single microchip nodes connected either wired in mesh-
like networks [6] or wireless using ad-hoc networks [8] with
limited energy supply and processing resources. But tradi-
tionally, mobile agents are processed on generic program-
controlled computer architectures using virtual machines
[7], [8], [18], [19], which usually cannot easily be reduced
to single microchip level like they are required in sensor-
ial materials. Furthermore, agents are treated with abstract
heavy-weighted knowledge-based models, not entirely match-
ing distributed data processing in sensor networks. In [3], a
multi-agent system is used for advanced image processing
making profit from the inherent parallel execution model of
Application specific digital logic hardware design has
advantages compared to program controlled microcontroller
approaches concerning power consumption, performance,
and chip resources by exploiting parallel data processing
(covered by the agent model) with lower clock frequencies
and enhanced performance [10].
1530-437X © 2014 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.
See for more information.
Fig. 1. Sensorial materials embedded in robots providing perception information of external applied load forces or internal structure load.
There are actually four major issues related to the scaling of
traditional software-based multi-agents systems to microchip
level and their design:
1) limited static processing, storage,and communication
resources, real-time processing,
2) unreliable communication,
3) suitable simplified programming models and processing
architectures offering hardware designs with finite state
machines (FSM) and resource sharing for parallel agent
execution, and
4) a generic high-level synthesis design approach.
Microchip level implementations of multi-agent systems were
originally proposed for low level tasks, for example in
[12] using agents to negotiate network resources and for high-
level tasks using agents to support human beings in ambient-
intelligence environments [14]. The first work implements the
agent behavior directly in hardware, the second uses still a
(configurable) microcontroller approach with optimized paral-
lel computational blocks providing instruction set extension.
A more general and reconfigurable implementation of agents
on microchip level is reported in [1], providing a closed-
loop design flow especially focussing on communication and
interaction, though still assuming and applying to program
controlled data processing machines and architectures. Hard-
ware implementations of multi-agent systems are still limited
to single or a few and non-mobile agents ([1], [20]).
In this work, an advanced high-level synthesis approach is
introduced to map the agent behavior of multi-agent systems
on microchip-level with an Agent-On-Chip processing archi-
tecture (AoC). The agent behavior, interaction, and mobility
are fully integrated on the microchip using a reconfigurable
pipelined communicating process architecture implemented
with finite-state machines and register-transfer logic. This
architecture supports parallel agent execution with a resource
shared pipeline approach. In this approach, the agent process-
ing is comparable to Petri Net token processing. A reconfigura-
tion mechanism of the agent processing system achieves some
kind of agent adaptation and algorithmic section based on
environmental changes like partial hardware or inter-connect
failures or based on learning and improved knowledge base.
The agent behavior, interaction, and mobility features
are modelled and specified with an activity-based agent
behavior programming language (AAPL). The activity-
graph based agent model is attractive due to the
proximity to the finite-state machine model, which simplifies
the hardware implementation. With this AAPL a high-level
agent compiler is able to synthesize a hardware model on
Register-Transfer Level (RTL, VHDL), alternatively a software
model (C, ML), or a simulation model (XML) suitable to
simulate a multi-agent system using the SeSAm simulator
framework [9]. Agent interaction and communication are
provided firstly by a simple tuple-space database implemented
on each node providing access and sharing of local data,
and secondly by signals able to propagate in the network
(like messages) preferred for fast and light-weighted remote
inter-node level communication and interaction. To enable
dynamic adaptation of the agent behavior at run-time, the
agent processing architecture implementing the agent behavior
can be (re)configured by agents by modifying the transitional
Traditionally agent programs are interpreted, leading to a
significant decrease in performance. In the approach presented
here the agent processing platform can directly be imple-
mented in standalone hardware nodes without intermediate
processing levels and without the necessity of an operating
system, but still enabling software implementations that can
be embedded in applications.
There is related work concerning agent programming lan-
guages and processing architectures, like APRIL[13] providing
tuple-space like agent communication, and widely used FIPA,
ACL,andKQGML[11] focusing on high-level knowledge
representation and exchange. All those approaches represent
communication and information on complex and abstract
level not fully suited for the synthesis of low-resource data
processing systems in distributed loosely coupled networks,
especially in sensor networks, in contrast to the proposed
AAPL approach, simple enough to enable hardware design
synthesis, but powerful enough to model the agent behavior
of complex distributed systems, which is demonstrated in the
following case study. Though the imperative programming
model is quite simple and closer to a traditional PL it can be
used as a common source and intermediate representation for
different agent processing platform implementations: hardware
(HW), software (SW), and simulation (SIM).
Fig. 2. Prototype of a Sensorial Material using intelligent sensor networks.
What is novel compared to other approaches?
Reliability and reactivity provided by the autonomy of
mobile state-based agents and reconfiguration.
Agent mobility and interaction by using tuple-space
databases and global signal propagation aid solving data
distribution and synchronization issues in distributed sys-
tems design, and tuple spaces represent agent belief.
One common agent programming language and process-
ing architecture enables the synthesis of standalone
parallel hardware implementations, alternatively stand-
alone software implementations, and behavioral simula-
tion models, enabling the design and test of large-scale
heterogeneous systems.
AAPL provides powerful statements for computation and
agent control with static resources.
A token-based pipelined multi-process agent process-
ing architecture suitable for hardware platforms with
Register-Transfer Level Logic offering optimized com-
putational resources and speed.
Improved scaling in large network applications compared
with full or semi centralized and pure message based
processing architectures.
Sensorial Materials are equipped with material-embedded
high miniaturized distributed sensor networks performing load
monitoring or environmental perception [15], shown in prin-
ciple in Fig. 1. These embedded sensor networks consist
of nodes equipped with sensor signal electronics and digital
logic performing computation and communication. Optionally
there are material-embedded energy sources (energy harvester)
supplying the nodes locally.
Fig. 2 shows a prototype of a Sensorial Material using
intelligent sensor networks. Each autonomous network node is
connected with up to four neighbors and strain-gauge sensors
mounted on a rubber sheet, altogether equipped with nine
bi- axial strain-gauge sensors placed at a distance of 70 mm.
The Sensorial Material was used to retrieve load information
about the sheet (applied by external forces) by using advanced
machine learning methods from a small set of uncalibrated
sensors with unknown electro-mechanical model still provid-
ing high spatial resolution compared with the distance of the
sensors to each other.
Fig. 3 shows the usage of such material in an intersection
element of a robot arm manipulator providing external envi-
ronmental perception required for robot control. The proposed
robot manipulator [16] consists of actors (joint drives) and
intersection elements with integrated smart sensor networks.
Distributed data processing is provided by mobile agents.
The agent behavior is implemented with SoC designs on
hardware-level. The intersection element connects two joint
actors with a rigid double-pipe construction, which is sur-
rounded by two opposite placed load sensitive skins (bent
rubber plate), equipped each with four strain-gauge sensor
pairs (bi-axially aligned). Each sensor pair is connected to a
sensor node providing parallel data processing, agent behavior
implementation, and communication/networking. All sensor
nodes are arranged in a mesh-like network connected with
serial point-to-point links. Communication is established by a
smart and robust routing protocol.
Initially, a sensor network is a collection of independent
computing nodes. Interaction between nodes is required to
manage and distribute data and to compute information.
One common interaction model is the state-based mobile
The behavior of a state-based agent can be easily mod-
elled with a finite-state machine completely implementable
with register-transfer logic (RTL) on microchip level eas-
ing high-level synthesis and the exploitation of concurrency