MaaS Consumer Agent (MCA)

At a Glance

• Category: Smart Automation
• Primary environment: MaaS Consumer
• Documentation focus: Design reference
• Maturity: TRL 3–4 (first release, M18)
• Related architecture docs: Reference Architecture Guide, Environments

Purpose

The MaaS Consumer Agent (MCA) is an intelligent, autonomous solution designed to operate within the MaaSAI ecosystem, facilitating service discovery, provider evaluation and contract negotiation. Its core components include an agent kernel built over JADE, a negotiation engine, a provider evaluation module and a learning and inference layer. Together, these modules enable autonomous decision-making, interaction with external systems, and transparent, explainable negotiation with MaaS Provider Agents.

Primary Actors

The D5.2 usage viewpoint defines roles, permissions, constraints, a role-task matrix, and a use case diagram for this solution.

• System administrator: Install, update and restart agents. Add users, delete users, edit users; constraint: Cannot perform actions related to edit negotiation policies, initiate and manage negotiations
• Consumer Power User: Define negotiation policies and thresholds. Modify access credentials to services Manage the knowledge base. Request and review negotiation explainability reports. Consult performance and statistics. Export negotiation reports.; constraint: Cannot manage other users (create, edit or delete)
• Consumer Analyst: Request and review negotiation explainability reports. Consult performance and statistics. Export negotiation reports.; constraint: Cannot perform actions related to editing negotiation policies, user administrations, knowledge base modifications, access credentials, initiate and manage negotiations
• Consumer Agent: Interpret service needs from Consumer Planner Discover and evaluate provider via Marketplace Initiate and manage negotiations Trigger smart contract creation and notify results; constraint: Cannot perform actions related to edit negotiation policies, user administrations, knowledge base modifications, access credentials.

Use-case diagram extracted from MaaSAI deliverable D5.2.

Functional Components

MCA brings together marketplace connectivity, offer evaluation, negotiation logic, explainability, and a knowledge base to support consumer-side automated decisions. The functional view shows how incoming offers are assessed, explained, and either accepted or escalated toward negotiation and contracting flows.

Functional components diagram extracted from MaaSAI deliverable D5.2.

Design Baseline

The JADE-based agent core orchestrates behaviour and communication. It implements a fully operational, FIPA-compliant agent using the Agent Communication Language (ACL), enabling standardised message exchange across agent platforms. To ensure consistent data exchange and semantic interoperability, ensuring that information exchanged between the MCA and other tools in the MaaSAI ecosystem (e.g., MaaS Provider Agent (MPA), Marketplace, Planners agent) is interpreted consistently, the agent references a shared domain ontology, defined in OWL (Web Ontology Language), which specifies manufacturing and negotiation concepts. JADE uses HTTP as the Message Transport Protocol (MTP) by default due to its simplicity during early development stages. Once the communication logic has been validated, the intention is to transition to XMPP to leverage its real-time messaging capabilities, improved reliability during network interruptions, and stronger built-in security.

The negotiation engine is implemented as an internal JADE behaviour within the agent. It manages the entire negotiation lifecycle, including proposal generation, timeout handling, and contract confirmation. This embedded approach ensures minimal latency and close coordination with other agent behaviours while making use of the built-in lifecycle and messaging mechanisms of the JADE framework.

The learning and inference layer is deployed as a standalone Python microservice that enhances the agent’s decision-making process with predictive analytics and explainable outputs (xAI). It draws on the agent’s knowledge base, storing historical negotiation data, provider profiles, and evaluation outcomes to justify actions and improve future decisions.

At the core of the MCA is the Agent Kernel and all the Java environment encapsulated in a Docker container. The agent, built on JADE, which ensures FIPA-compliant communication through ACL. This kernel orchestrates different behaviours which support service discovery and request exchange through the Marketplace Communication Module, manages interactions with MPA through Agent Communication Module and implements the negotiation lifecycle, including proposal generation, timeout handling and contract confirmation through the Negotiation Engine. To ensure consistent interoperation of manufacturing and negotiation concepts, the MCA references a shared domain ontology defined in OWL. This guarantees that messages exchanged between agents and other MaaSAI components are semantically aligned. The MCA integrates a Learning & Inference Module, deployed as a Python microservice in Docker. This layer uses historical negotiation data and performance metrics stored in the Knowledge Base. It applies predictive analytics via TensorFlow to optimize negotiation strategies. To ensure transparency in decision-making, it provides explainable outputs using SHAP/LIME. In order to enable modular integration with the Java environment it exposes its functionality through FastAPI.

The Knowledge Base serves as a repository for structured data on past negotiations, evaluations and outcomes. The xAI User Interface allows the consumer to interact with the MCA, review recommendations, and understand the rationale behind decisions. This promotes confidence in autonomous operations and facilitates oversight.

Architecture diagram extracted from MaaSAI deliverable D5.2.

Technology Stack

The MaaS Agents (MCA and its provider-side counterpart, the MaaS Provider Agent) are built entirely on open-source technologies.

Category	Technology
AI/Agents	Python (> 3.9), SPADE multi-agent framework (XMPP messaging, asynchronous programming), NegMas for the negotiation logic (issue representation, utility-based offer evaluation, concession strategies, counteroffer generation)
Backend/Communication	FastAPI for REST endpoints, Paho MQTT clients, Prosody XMPP server for internal agent communication
Data	PostgreSQL with the TimescaleDB extension for negotiation time series
Frontend	React and Vite (testing and monitoring interface)
Containerisation	Docker / Docker Compose
Licences	open source throughout — mainly MIT (SPADE, FastAPI, React, Prosody), plus Apache 2.0, BSD 3-Clause, EPL-2.0/EDL-1.0 and ISC components

Integrations & External Dependencies

A MaaS Consumer Orchestrator Agent (MCOA), hosted in the consumer’s own infrastructure, deploys MCA instances on demand — one per provider under negotiation. The agents register with and are driven by the Cloud MaaS Marketplace (CMM), while the negotiation between MCAs and MPAs runs over the secure MQTT broker provided by Point-to-point Secure Messaging (PSM, WP8). Future integrations include the MaaS Consumer Planner (WP12), which will be able to trigger new requests automatically, and the Edge Data Storage.

APIs & Interfaces

The consumer side exposes REST endpoints invoked by CMM, complemented by MQTT topics and a web UI:

• POST /requests/{request_id}/candidates — receive the list of potential resources from CMM
• GET /requests/{request_id}/context — return the consumer’s sorting/filtering criteria
• POST /requests/{request_id}/negotiations/parties and .../start — receive the 1–3 selected resources and launch child MCA agents
• GET /requests/{request_id}/negotiations/terms and POST .../decision — expose offer terms and consolidate the final user decision
• MQTT: a discovery topic to activate provider-side agents, and per-negotiation bilateral topics with from_consumer / from_provider lanes
• React frontend to configure agents (competitive, neutral or flexible profiles, weights, parameter ranges) and monitor negotiations round by round

User Interface

Representative screens of the agents’ user interface in the first release:

Agents’ user interface — main screen — MaaSAI deliverable D6.1.

Agents’ user interface — negotiations screen — MaaSAI deliverable D6.1.

Deployment & Configuration

The solution is fully containerised and deployed as a Docker Compose stack: a Prosody XMPP server, the orchestrator agent backend, a PostgreSQL/TimescaleDB database and the React frontend (users holding both consumer and provider roles host both orchestrators). No host dependencies are required beyond the container engine.

Requirement	Minimum	Recommended
CPU	2 vCPUs	4+ vCPUs
RAM	4 GB	8–16 GB
Storage	20 GB	SSD
GPU	—	CUDA GPU (for future reinforcement-learning workloads)
OS	—	Linux